home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 38 / Amiga Format CD38 (1999-03-15)(Future Publishing)(GB)(Track 1 of 3)[!][issue 1999-04].iso / -websites- / haage&partner / ftp / warpup / warpup_release2.lha / WarpUP-WarpOS / Docs / powerpc.doc
Text File  |  1997-10-21  |  97KB  |  3,339 lines
  1. TABLE OF CONTENTS
  2.  
  3. powerpc.library/AllocVec32
  4. powerpc.library/AllocXMsg
  5. powerpc.library/FreeVec32
  6. powerpc.library/FreeXMsg
  7. powerpc.library/GetCPU
  8. powerpc.library/GetPPCState
  9. powerpc.library/PowerDebugMode
  10. powerpc.library/PutXMsg
  11. powerpc.library/RunPPC
  12. powerpc.library/SPrintF68K
  13. powerpc.library/WaitForPPC
  14.  
  15. powerpc.library/AddHeadPPC
  16. powerpc.library/AddPortPPC
  17. powerpc.library/AddSemaphorePPC
  18. powerpc.library/AddTailPPC
  19. powerpc.library/AddTimePPC
  20. powerpc.library/AllocSignalPPC
  21. powerpc.library/AllocVecPPC
  22. powerpc.library/AllocXMsgPPC
  23. powerpc.library/AttemptSemaphorePPC
  24. powerpc.library/ChangeMMU
  25. powerpc.library/ClearExcMMU
  26. powerpc.library/CmpTimePPC
  27. powerpc.library/CopyMemPPC
  28. powerpc.library/CreateMsgPortPPC
  29. powerpc.library/CreateTaskPPC
  30. powerpc.library/DeleteMsgPortPPC
  31. powerpc.library/DeleteTaskPPC
  32. powerpc.library/EndSnoopTask
  33. powerpc.library/EnqueuePPC
  34. powerpc.library/FindNamePPC
  35. powerpc.library/FindPortPPC
  36. powerpc.library/FindSemaphorePPC
  37. powerpc.library/FindTagItemPPC
  38. powerpc.library/FindTaskPPC
  39. powerpc.library/FreeAllMem
  40. powerpc.library/FreeSemaphorePPC
  41. powerpc.library/FreeSignalPPC
  42. powerpc.library/FreeVecPPC
  43. powerpc.library/FreeXMsgPPC
  44. powerpc.library/GetInfo
  45. powerpc.library/GetMsgPPC
  46. powerpc.library/GetSysTimePPC
  47. powerpc.library/GetTagDataPPC
  48. powerpc.library/InitSemaphorePPC
  49. powerpc.library/InsertPPC
  50. powerpc.library/LockTaskList
  51. powerpc.library/ModifyFPExc
  52. powerpc.library/NextTagItemPPC
  53. powerpc.library/ObtainSemaphorePPC
  54. powerpc.library/PutMsgPPC
  55. powerpc.library/PutXMsgPPC
  56. powerpc.library/ReleaseSemaphorePPC
  57. powerpc.library/RemExcHandler
  58. powerpc.library/RemHeadPPC
  59. powerpc.library/RemovePPC
  60. powerpc.library/RemPortPPC
  61. powerpc.library/RemTailPPC
  62. powerpc.library/RemSemaphorePPC
  63. powerpc.library/ReplyMsgPPC
  64. powerpc.library/Run68K
  65. powerpc.library/SetCache
  66. powerpc.library/SetExcHandler
  67. powerpc.library/SetExcMMU
  68. powerpc.library/SetHardware
  69. powerpc.library/SetReplyPortPPC
  70. powerpc.library/SetSignalPPC
  71. powerpc.library/SetTaskPriPPC
  72. powerpc.library/Signal68K
  73. powerpc.library/SignalPPC
  74. powerpc.library/SnoopTask
  75. powerpc.library/SPrintF
  76. powerpc.library/SubTimePPC
  77. powerpc.library/Super
  78. powerpc.library/UnLockTaskList
  79. powerpc.library/User
  80. powerpc.library/WaitFor68K
  81. powerpc.library/WaitPortPPC
  82. powerpc.library/WaitPPC
  83. powerpc.library/WaitTime
  84.  
  85. powerpc.library/AllocVec32                          powerpc.library/AllocVec32
  86.  
  87.     NAME
  88.     AllocVec32 - allocates memory which is correctly aligned (V7)
  89.  
  90.     CPU
  91.     680x0
  92.  
  93.     SYNOPSIS
  94.     memblock = AllocVec32(memsize, attributes)
  95.     d0                    d0       d1
  96.  
  97.     void *AllocVec32(ULONG, ULONG);
  98.  
  99.     FUNCTION
  100.     This function allocates memory via exec/AllocVec and aligns the
  101.     memory block properly, so that this memory block can be shared
  102.     with PPC tasks. The minimal alignment of the memory block is 32.
  103.  
  104.     INPUTS
  105.     memsize - size of memory to be allocated
  106.     attributes - the desired memory attributes (see exec/AllocMem for
  107.              a description of these attributes)
  108.  
  109.     RESULT
  110.     memblock - The address of the allocated memory block
  111.  
  112.     NOTES
  113.     Memory blocks allocated with 'AllocVec32' must be freed using
  114.     'FreeVec32'.
  115.  
  116.     SEE ALSO
  117.     FreeVec32, exec/AllocMem
  118.  
  119. powerpc.library/AllocXMsg                            powerpc.library/AllocXMsg
  120.  
  121.     NAME
  122.     AllocXMsg - allocates a message for Inter-CPU communication (V12)
  123.  
  124.     CPU
  125.     680x0
  126.  
  127.     SYNOPSIS
  128.     message = AllocXMsg(bodysize, replyport)
  129.     d0                  d0        a0
  130.  
  131.     struct Message *AllocXMsg(ULONG, struct MsgPort *);
  132.  
  133.     FUNCTION
  134.     This function allocates memory for a message which can be used
  135.     for Inter-CPU communication. Some fields of the message are
  136.     initialized.
  137.     After this function was called, the message body must be
  138.     created before sending this message.
  139.  
  140.     INPUTS
  141.     bodysize - the size of the message body (max. 65535-MN_SIZE)
  142.     replyport - the reply port
  143.  
  144.     RESULT
  145.     message - The address of an initialized message (except for
  146.           the message body, which must be initialized by the
  147.           programmer).
  148.  
  149.     NOTES
  150.     Calling this function is the only way allowed to create a
  151.     message which can be sent to a PPC task.
  152.  
  153.     A message allocated with 'AllocXMsg' should be freed using
  154.     'FreeXMsg' if it is not used anymore.
  155.  
  156.     An Inter-CPU message must be sent with 'PutXMsg' to a PPC
  157.     task.
  158.  
  159.     A replyport should always be specified. Inter-CPU messages
  160.     should always be replied and the reply should be read.
  161.  
  162.     It is possible not to specify a replyport (simply set
  163.     replyport to NULL). But don't forget that the message
  164.     must NOT be freed by a PPC task!
  165.  
  166.     SEE ALSO
  167.     FreeXMsg, PutXMsg
  168.  
  169. powerpc.library/FreeVec32                            powerpc.library/FreeVec32
  170.  
  171.     NAME
  172.     FreeVec32 - frees memory allocated with 'AllocVec32' (V7)
  173.  
  174.     CPU
  175.     680x0
  176.  
  177.     SYNOPSIS
  178.     FreeVec32(memblock)
  179.           a1
  180.  
  181.     void FreeVec32(void *);
  182.  
  183.     FUNCTION
  184.     This function frees a memory block which was allocated using
  185.     'AllocVec32'.
  186.  
  187.     INPUTS
  188.     memblock - The address of the allocated memory block
  189.  
  190.     SEE ALSO
  191.     AllocVec32
  192.  
  193. powerpc.library/FreeXMsg                              powerpc.library/FreeXMsg
  194.  
  195.     NAME
  196.     FreeXMsg - frees a message allocated with 'AllocXMsg' (V12)
  197.  
  198.     CPU
  199.     680x0
  200.  
  201.     SYNOPSIS
  202.     FreeXMsg(message)
  203.          a1
  204.  
  205.     void FreeXMsg(struct Message *);
  206.  
  207.     FUNCTION
  208.     This function frees a memory allocated using 'AllocXMsg'.
  209.  
  210.     INPUTS
  211.     message - a message allocated by 'AllocXMsg'.
  212.  
  213.     NOTES
  214.     [An Inter-CPU message must not be freed, if it was sent to
  215.     a PPC task and the reply has not yet arrived back.]
  216.  
  217.     The above statement is not valid anymore. Inter-CPU-Messages
  218.     can be freed by another PPC task even if it wasn't replied.
  219.  
  220.     SEE ALSO
  221.     AllocXMsg, PutXMsg
  222.  
  223. powerpc.library/GetCPU                                  powerpc.library/GetCPU
  224.  
  225.     NAME
  226.     GetCPU - gets the PowerPC CPU type (V7)
  227.  
  228.     CPU
  229.     680x0
  230.  
  231.     SYNOPSIS
  232.     CPUType = GetCPU
  233.     d0
  234.  
  235.     ULONG GetCPU (void);
  236.  
  237.     FUNCTION
  238.     This function reads the PowerPC CPU type. A longword is returned with
  239.     one specific bit set (see the include file 'powerpc/powerpc.i' for a
  240.     description of the different CPU types)
  241.  
  242.     RESULT
  243.     CPUType - A longword with one specific bit set.
  244.  
  245. powerpc.library/GetPPCState                        powerpc.library/GetPPCState
  246.  
  247.     NAME
  248.     GetPPCState - returns the state of the PPC and PPC applications (V13)
  249.  
  250.     CPU
  251.     680x0
  252.  
  253.     SYNOPSIS
  254.     PPCState = GetPPCState
  255.     d0
  256.  
  257.     ULONG GetPPCState (void);
  258.  
  259.     FUNCTION
  260.     This function returns the current state of the PPC processor and
  261.     the state of custom applications. A bitmask is returned with the
  262.     values defined in 'powerpc.i'.
  263.  
  264.     RESULT
  265.     PPCState - A bitmask. The following bits are supported (the
  266.            description is valid if the bit is 1):
  267.  
  268.            PPCSTATEF_POWERSAVE  - PPC is currently in power save mode.
  269.            PPCSTATEF_APPACTIVE  - PPC application tasks are currently
  270.                     - active resp. installed in the system.
  271.            PPCSTATEF_APPRUNNING - At least one PPC application task is
  272.                       ready or running.
  273.  
  274. powerpc.library/PowerDebugMode                  powerpc.library/PowerDebugMode
  275.  
  276.     NAME
  277.     PowerDebugMode - sets the level of debugging output (V7)
  278.  
  279.     CPU
  280.     680x0
  281.  
  282.     SYNOPSIS
  283.     PowerDebugMode (debuglevel)
  284.             d0
  285.  
  286.     void PowerDebugMode (ULONG);
  287.  
  288.     FUNCTION
  289.     The powerpc.library has a built-in debugging system which prints out
  290.     many informations to the serial port. The main purpose of this
  291.     function is to improve the maintenance of this library. If problems
  292.     occur with the powerpc.library then it will help the author of this
  293.     library a lot to fix the problems. Try to reproduce the problems with
  294.     debugging output enabled and send the debugging output to the author.
  295.     Use a program which captures the data transferred to the serial port
  296.     (for example Sushi) to save the debugging output.
  297.  
  298.     INPUTS
  299.     debuglevel - Debugging level (0-3). All other values are ignored.
  300.              The higher the debugging level, the larger the debugging
  301.              output. 0 means no debugging output.
  302.  
  303.     NOTES
  304.     The powerpc.library operates with debugging level 0 by default (no
  305.     debugging output). You can change the default value with the
  306.     environment variable 'powerpc/debug' (set values from 0 to 3).
  307.  
  308. powerpc.library/PutXMsg                                powerpc.library/PutXMsg
  309.  
  310.     NAME
  311.     PutXMsg - sends an Inter-CPU message to a PPC task (V12)
  312.  
  313.     CPU
  314.     680x0
  315.  
  316.     SYNOPSIS
  317.     PutXMsg(MsgPortPPC, message)
  318.         a0          a1
  319.  
  320.     void PutXMsg(struct MsgPortPPC *, struct Message *);
  321.  
  322.     FUNCTION
  323.     This function sends an Inter-CPU message allocated by 'AllocXMsg'
  324.     to a PPC task.
  325.  
  326.     INPUTS
  327.     MsgPortPPC - a PPC message port
  328.     message - a message allocated by 'AllocXMsg'.
  329.  
  330.     NOTES
  331.     Inter-CPU must NOT be used for internal communication. They can
  332.     only be used for communication between tasks on different processors.
  333.  
  334.     Inter-CPU messages get a different node type, if they are
  335.     sent. If you want to filter out Reply-Messages from standard
  336.     or Inter-CPU messages, compare the LN_TYPE field to NT_REPLYMSG.
  337.     Replied Inter-CPU messages still get the same node type
  338.     (NT_REPLYMSG). Any assumptions about the value of the new
  339.     node type are ILLEGAL!!
  340.  
  341.     As soon as an Inter-CPU message is sent, the 68K looses ownership
  342.     over the message. No access to the message is allowed until the
  343.     reply has been arrived.
  344.  
  345.     Inter-CPU messages can be reused if they have been replied.
  346.  
  347.     Inter-CPU messages are read and replied using the standard
  348.     message handling mechanisms (exec/WaitPort,exec/GetMsg,exec/ReplyMsg
  349.     for 68K, powerpc/WaitPortPPC, powerpc/GetMsgPPC, powerpc/ReplyMsgPPC
  350.     for PPC).
  351.  
  352.     Don't call exec/ReplyMsg with an InterCPU-Message without
  353.     Replyport (versions less than V12.2 crashed).
  354.  
  355.     The receiving task must NOT access message data, which are not
  356.     explicitely located in the message body (for example data which is
  357.     referenced by a pointer) unless both tasks care for the cache
  358.     consistency. Only the message itself is flushed/invalidated
  359.     automatically by the system.
  360.  
  361.     The receiving task may write to the message body of an Inter-CPU
  362.     message.
  363.  
  364.     Inter-CPU messages should always be replied and the reply should
  365.     be read and filtered out.
  366.  
  367.     SEE ALSO
  368.     AllocXMsg, FreeXMsg
  369.  
  370. powerpc.library/RunPPC                                  powerpc.library/RunPPC
  371.  
  372.     NAME
  373.     RunPPC - runs a PowerPC function (V7)
  374.  
  375.     CPU
  376.     680x0
  377.  
  378.     SYNOPSIS
  379.     status = RunPPC(PPStruct)
  380.     d0              a0
  381.  
  382.     LONG RunPPC (struct PowerPC *);
  383.  
  384.     FUNCTION
  385.     Runs a PowerPC function. A mirror PPC process is created. All
  386.     registers can be transferred to PPC as well as parameters on
  387.     stack. All cache management actions are handled automatically.
  388.  
  389.     All registers are transferred back from PPC after the PPC call
  390.     is completed. They are stored in the PowerPC structure.
  391.  
  392.     The register assignment is as follows:
  393.  
  394.     d0      <->     r3              fp0     <->     f1
  395.     d1      <->     r4              fp1     <->     f2
  396.     d2      <->     r22             fp2     <->     f3
  397.     d3      <->     r23             fp3     <->     f4
  398.     d4      <->     r24             fp4     <->     f5
  399.     d5      <->     r25             fp5     <->     f6
  400.     d6      <->     r26             fp6     <->     f7
  401.     d7      <->     r27             fp7     <->     f8
  402.     a0      <->     r5
  403.     a1      <->     r6
  404.     a2      <->     r28
  405.     a3      <->     r29
  406.     a4      <->     r2
  407.     a5      <->     r30
  408.     a6      <->     r31
  409.  
  410.     Please note, that these registers are NOT transferred directly but
  411.     in the register array mentioned above (PP_REGS).
  412.  
  413.     Here follows another table from the PPC's point of view:
  414.  
  415.     PPC-Register:                   Index into the register array:
  416.     ---------------------------------------------------------------
  417.     Base register:
  418.     r2                              12
  419.  
  420.     Scratch registers:
  421.     r3                              0
  422.     r4                              1
  423.     r5                              8
  424.     r6                              9
  425.  
  426.     Nonvolatile registers:
  427.     r22                             2
  428.     r23                             3
  429.     r24                             4
  430.     r25                             5
  431.     r26                             6
  432.     r27                             7
  433.     r28                             10
  434.     r29                             11
  435.     r30                             13
  436.     r31                             14
  437.  
  438. INPUTS
  439.     PPStruct - Pointer to an initialized PowerPC Structure
  440.  
  441.       PP_CODE       : Pointer to the PowerPC code
  442.       PP_OFFSET     : Not used until V12.2 of powerpc.library. From
  443.               V12.3 on, the PP_OFFSET field is used just like
  444.               at Run68K. If PP_OFFSET is zero, than the code
  445.               pointed to by PP_CODE is executed, if PP_OFFSET
  446.               is not zero, a PPC library function is executed
  447.               with PP_CODE containing the library base and
  448.               PP_OFFSET containing the library vector offset.
  449.       PP_FLAGS      : Flags which can be ore'd together
  450.       - PP[F/B]_ASYNC   : Call PPC function asynchronely (68K process
  451.                   returns immediately)
  452.       PP_STACKPTR   : Pointer to the arguments on the stack to be
  453.               transferred. The pointer must point directly
  454.               to the first argument, not to the return address!
  455.               If no arguments on stack should be transferred,
  456.               set this to zero.
  457.       PP_STACKSIZE  : Size of the stack area to be transferred. If no
  458.               stack parameters should be transferred, set this
  459.               to zero.
  460.       PP_REGS       : Array of longwords where the registers to be
  461.               transferred can be stored (d0-a6). Please see
  462.               above for the exact placement of these registers.
  463.       PP_FREGS      : Array of quadwords (8 bytes) where the FP-registers
  464.               to be transferred can be stored (fp0-fp7). fp0 is
  465.               at offset 0, fp1 at offset 8 etc.
  466.  
  467.     RESULT
  468.     status - PPERR_SUCCESS if the call was successfully
  469.          PPERR_ASYNCERR if a synchrone PPC call was made after an
  470.                 asynchrone PPC call
  471.  
  472.     NOTES
  473.     Calling a PPC function asynchronely is dangerous. Take care of
  474.     possible cache conflicts. Avoid calling system functions as much
  475.     as possible.
  476.  
  477.     If an asynchrone PPC call is done, the function WaitForPPC MUST be
  478.     called ONCE after the call was done. No other PPC call is allowed
  479.     for this 68K process after an asynchrone PPC call and before a call
  480.     to WaitForPPC.
  481.  
  482.     If an asynchronely called PPC function performs a 68K call, the call
  483.     is only performed when WaitForPPC is called by the 68K process. Note
  484.     that the PPC mirror process is still connected to the calling 68K
  485.     process.
  486.  
  487.     DON'T pass arguments on stack when calling a PPC function asynchronely.
  488.     The stack is most likely to be trashed before it is copied to the PPC
  489.     stack.
  490.  
  491.     Assembler programmers should use the macros RUNPOWERPC and
  492.     RUNPOWERPC_XL located in the include file 'powerpc/powerpc.i'
  493.  
  494.     SEE ALSO
  495.     WaitForPPC,powerpc/powerpc.i
  496.  
  497. powerpc.library/SPrintF68K                          powerpc.library/SPrintF68K
  498.  
  499.     NAME
  500.     SPrintF68K - prints a formatted string to the serial port (V7)
  501.  
  502.     CPU
  503.     680x0
  504.  
  505.     SYNOPSIS
  506.     SPrintF68K (Formatstring, values )
  507.             a0            a1
  508.  
  509.     void SPrintF68K (STRPTR, APTR);
  510.  
  511.     FUNCTION
  512.     Prints a formatted string to the serial port using the AMIGA-OS
  513.     functions 'exec/RawPutChar' and 'exec/RawDoFmt'. Can be used to add
  514.     debugging features and to improve the maintenance of software.
  515.  
  516.     INPUTS
  517.     Formatstring - A C style string with % commands to indicate where
  518.                parameters have to be inserted (see 'exec/RawDoFmt'
  519.                for a detailed description of these commands).
  520.     values - A pointer to an array of parameters to be inserted into
  521.          specified places in the string.
  522.  
  523.     SEE ALSO
  524.     exec/RawDoFmt
  525.  
  526. powerpc.library/WaitForPPC                          powerpc.library/WaitForPPC
  527.  
  528.     NAME
  529.     WaitForPPC - waits for the completion of an asynchrone PPC call (V7)
  530.  
  531.     CPU
  532.     680x0
  533.  
  534.     SYNOPSIS
  535.     status = WaitForPPC(PPStruct)
  536.     d0                  a0
  537.  
  538.     LONG WaitForPPC (struct PowerPC *);
  539.  
  540.     FUNCTION
  541.     After an asynchrone PPC call was done (see RunPPC) this function must
  542.     be called to wait for the completion of the PowerPC function. All
  543.     registers transferred to the PowerPC with RunPPC are returned into the
  544.     PowerPC Structure.
  545.  
  546.     INPUTS
  547.     PPStruct - Pointer to a PowerPC Structure (see RunPPC for a description
  548.            of the elements). The structure has not to be initialized.
  549.            The structure must be transferred to hold the returned
  550.            registers by the PPC function.
  551.  
  552.     RESULT
  553.     status - PPERR_SUCCESS if the call was successfully
  554.          PPERR_WAITERR if WaitForPPC is called after a synchrone PPC
  555.                    call.
  556.  
  557.     NOTES
  558.     Assembler programmers should use the macros WAITFORPPC and
  559.     WAITFORPPC_XL located in the include file 'powerpc/powerpc.i'
  560.  
  561.     SEE ALSO
  562.     RunPPC,powerpc/powerpc.i
  563.  
  564. powerpc.library/AddHeadPPC                          powerpc.library/AddHeadPPC
  565.  
  566.     NAME
  567.     AddHeadPPC - insert a node at the head of a list (V8)
  568.  
  569.     CPU
  570.     PowerPC
  571.  
  572.     SYNOPSIS
  573.     AddHeadPPC(_PowerPCBase, list, node)
  574.            r3            r4    r5
  575.  
  576.     void AddHeadPPC(struct Library *, struct List*, struct Node*);
  577.  
  578.     FUNCTION
  579.     Insert a node to the head of a standard exec list. This is the
  580.     mirror function of exec/AddHead.
  581.  
  582.     INPUTS
  583.     _PowerPCBase - base of powerpc.library (can be omitted)
  584.     list - a pointer to the target list
  585.     node - the node to insert
  586.  
  587.     NOTES
  588.     This function is guaranteed to work correctly, if the PowerPCBase
  589.     is not passed in r3.
  590.  
  591.     Assembler programmers may use the macro _ADDHEAD located in
  592.     'powerpc/listsPPC.i'
  593.  
  594.     This function is safe to call from exception handlers.
  595.  
  596.     SEE ALSO
  597.     InsertPPC, AddTailPPC, RemovePPC, RemHeadPPC, RemTailPPC,
  598.     EnqueuePPC, FindNamePPC, powerpc/listsPPC.i
  599.  
  600. powerpc.library/AddPortPPC                          powerpc.library/AddPortPPC
  601.  
  602.     NAME
  603.     AddPortPPC - adds a public PPC message port to the system (V11)
  604.  
  605.     CPU
  606.     PowerPC
  607.  
  608.     SYNOPSIS
  609.     AddPortPPC(_PowerPCBase, MsgPortPPC)
  610.            r3            r4
  611.  
  612.     void AddPortPPC(struct Library *, struct MsgPortPPC *);
  613.  
  614.     FUNCTION
  615.     This function adds a PPC message port to a public list of ports.
  616.     The message port should be named and the priority field should
  617.     be set. A public message port can be found by name using
  618.     'FindPortPPC'. This is the mirror function of exec/AddPort.
  619.  
  620.     INPUTS
  621.     _PowerPCBase - base of powerpc.library
  622.     MsgPortPPC - pointer to a PPC message port. It's safe to pass a
  623.              NULL parameter.
  624.  
  625.     SEE ALSO
  626.     CreateMsgPortPPC,DeleteMsgPortPPC,FindPortPPC,RemPortPPC
  627.     powerpc/portsPPC.i
  628.  
  629. powerpc.library/AddSemaphorePPC                powerpc.library/AddSemaphorePPC
  630.  
  631.     NAME
  632.     AddSemaphorePPC - initializes a global signal semaphore (V8)
  633.  
  634.     CPU
  635.     PowerPC
  636.  
  637.     SYNOPSIS
  638.     status = AddSemaphorePPC(_PowerPCBase, SignalSemaphorePPC)
  639.     r3                        r3            r4
  640.  
  641.     LONG AddSemaphorePPC(struct Library *, struct SignalSemaphorePPC *);
  642.  
  643.     FUNCTION
  644.     Initializes a signal semaphore and adds it to the public semaphore
  645.     list. This is the mirror function of exec/AddSemaphore.
  646.  
  647.     INPUTS
  648.     _PowerPCBase - base of powerpc.library
  649.     SignalSemaphorePPC - pointer to a signalsemaphorePPC structure
  650.                  (a semaphore name should be specified)
  651.  
  652.     RESULT
  653.     status - status value:
  654.         SSPPC_SUCCESS: function was successful
  655.         SSPPC_NOMEM: function failed due to lack of memory
  656.  
  657.     SEE ALSO
  658.     InitSemaphorePPC, FreeSemaphorePPC, ObtainSemaphorePPC,
  659.     AttemptSemaphorePPC, ReleaseSemaphorePPC, RemSemaphorePPC,
  660.     FindSemaphorePPC, powerpc/semaphoresPPC.i
  661.  
  662. powerpc.library/AddTailPPC                          powerpc.library/AddTailPPC
  663.  
  664.     NAME
  665.     AddTailPPC - insert a node at the tail of a list (V8)
  666.  
  667.     CPU
  668.     PowerPC
  669.  
  670.     SYNOPSIS
  671.     AddTailPPC(_PowerPCBase, list, node)
  672.            r3            r4    r5
  673.  
  674.     void AddTailPPC(struct Library *, struct List*, struct Node*);
  675.  
  676.     FUNCTION
  677.     Insert a node to the tail of a standard exec list. This is the
  678.     mirror function of exec/AddTail.
  679.  
  680.     INPUTS
  681.     _PowerPCBase - base of powerpc.library (can be omitted)
  682.     list - a pointer to the target list
  683.     node - the node to insert
  684.  
  685.     NOTES
  686.     This function is guaranteed to work correctly, if the PowerPCBase
  687.     is not passed in r3.
  688.  
  689.     Assembler programmers may use the macro _ADDTAIL located in
  690.     'powerpc/listsPPC.i'
  691.  
  692.     This function is safe to call from exception handlers.
  693.  
  694.     SEE ALSO
  695.     InsertPPC, AddHeadPPC, RemovePPC, RemHeadPPC, RemTailPPC,
  696.     EnqueuePPC, FindNamePPC, powerpc/listsPPC.i
  697.  
  698. powerpc.library/AddTimePPC                          powerpc.library/AddTimePPC
  699.  
  700.     NAME
  701.     AddTimePPC - adds one time request to another (V7)
  702.  
  703.     CPU
  704.     PowerPC
  705.  
  706.     SYNOPSIS
  707.     AddTimePPC(_PowerPCBase, Dest, Source)
  708.            r3            r4    r5
  709.  
  710.     void AddTimePPC(struct Library *, struct timeval *, struct timeval *);
  711.  
  712.     FUNCTION
  713.     This routine adds one timeval structure to another. The results are
  714.     stored in the destination (Dest + Source -> Dest)
  715.  
  716.     This is the mirror function of timer/AddTime.
  717.  
  718.     INPUTS
  719.     _PowerPCBase - base of powerpc.library
  720.     Dest - pointer to a timeval structure
  721.     Source - pointer to a timeval structure
  722.  
  723.     NOTES
  724.     This function is safe to call from exception handlers
  725.  
  726.     SEE ALSO
  727.     GetSysTimePPC, SubTimePPC, CmpTimePPC
  728.  
  729. powerpc.library/AllocSignalPPC                  powerpc.library/AllocSignalPPC
  730.  
  731.     NAME
  732.     AllocSignalPPC - allocate a signal (V8)
  733.  
  734.     CPU
  735.     PowerPC
  736.  
  737.     SYNOPSIS
  738.     signalnum = AllocSignalPPC(_PowerPCBase, signalNum)
  739.     r3                         r3            r4
  740.  
  741.     LONG AllocSignalPPC(struct Library *, LONG);
  742.  
  743.     FUNCTION
  744.     Allocate a signal bit from the current task's pool. Either a
  745.     particular bit or the next free bit may be allocated. This
  746.     is the mirror function of exec/AllocSignal.
  747.  
  748.     INPUTS
  749.     _PowerPCBase - base of powerpc.library
  750.     signalNum - the desired signal bit number (0..31) or -1
  751.             if the next free bit should be allocated
  752.  
  753.     RESULT
  754.     signalnum - the signal bit allocated or -1 for failure.
  755.  
  756.     NOTES
  757.     IMPORTANT: The signal bit numbers are returned in the
  758.     68K notation! For example, if the number 27 is returned,
  759.     the waiting mask must be $08000000.
  760.  
  761.     All signal allocations are kept coherent on both CPU's.
  762.     A signal allocated on the 68K side is not free anymore
  763.     for the mirror PPC task and vice versa. The PPC also
  764.     can wait for signals or send signals allocated on the
  765.     68K side and vice versa (V11).
  766.  
  767.     SEE ALSO
  768.     FreeSignalPPC, SetSignalPPC, SignalPPC, WaitPPC
  769.  
  770. powerpc.library/AllocVecPPC                        powerpc.library/AllocVecPPC
  771.  
  772.     NAME
  773.     AllocVecPPC - allocates memory for PPC with MMU support (V7)
  774.  
  775.     CPU
  776.     PowerPC
  777.  
  778.     SYNOPSIS
  779.     memblock = AllocVecPPC(_PowerPCBase, memsize, attributes, alignment)
  780.     r3                     r3            r4       r5          r6
  781.  
  782.     void *AllocVecPPC(struct Library *, ULONG, ULONG, ULONG);
  783.  
  784.     FUNCTION
  785.     This function allocates memory which is correctly aligned for the use
  786.     by PowerPC applications. It's the mirror function of exec/AllocVec
  787.     but offers some additional features.
  788.     AllocVecPPC supports user defined alignment and allocation of memory-
  789.     blocks with a desired cache mode (MMU support only for V9+)
  790.     Since V12, it's possible to allocate memory, which is protected
  791.     against other tasks (either full- or write-protected).
  792.  
  793.     INPUTS
  794.     _PowerPCBase - base of powerpc.library
  795.     memsize - the amount of memory to be allocated.
  796.     attributes - the requirements as explained in exec/AllocMem
  797.              This function offers some additional attributes:
  798.  
  799.         MEMF_WRITETHROUGH: maps the allocated memory as writethrough
  800.         MEMF_COPYBACK:     maps the allocated memory as copyback
  801.         MEMF_CACHEON:      maps the allocated memory as cachable
  802.         MEMF_CACHEOFF:     maps the allocated memory as noncachable
  803.         MEMF_GUARDED:      maps the allocated memory as guarded
  804.         MEMF_NOTGUARDED:   maps the allocated memory as not guarded
  805.         MEMF_BAT:          puts the allocated memory block into a
  806.                    BAT register
  807.         MEMF_PROTECT:      the memory block should be full-protected
  808.                    against other tasks (no user-accesses of
  809.                    other tasks allowed).
  810.         MEMF_WRITEPROTECT: the memory block should be write-protected
  811.                    against other tasks (no user-write-acesses
  812.                    of other tasks allowed).
  813.  
  814.     alignment - the desired alignment of the memory block. The system
  815.             may round this value up to a minimal alignment. It's
  816.             safe to pass 0 as alignment.
  817.  
  818.     RESULT
  819.     memblock - The address of the allocated memory. If the
  820.            memory couldn't be allocated 0 is returned.
  821.  
  822.     NOTES
  823.     The amount of memory effectively allocated is usually bigger
  824.     than the given memsize. It's not a good idea to call this
  825.     function many times to allocate very small pieces of memory.
  826.  
  827.     If some of the additional memflags are specified, the alignment
  828.     and the size is internally rounded up to meet the requirements
  829.     of the MMU.
  830.  
  831.     The additional MMU memflags are intended for highly optimizing
  832.     code and shoud not be used by standard applications.
  833.  
  834.     The memflag MEMF_BAT can improve the performance of the memory
  835.     accesses heavily (especially on CPU's with software tablesearch).
  836.     But DON'T use this flag unless you really need the speed. Note:
  837.     The required free memory has to be much bigger than the size of
  838.     the memory to be allocated, because there are severe alignment
  839.     restrictions when using BAT registers.
  840.  
  841.     The memflag MEMF_BAT has no effect if the task runs with BAT MMU
  842.     Setup.
  843.  
  844.     Note that no other tasks should access memory which was allocated
  845.     using special MMU memflags, because the other task can probably
  846.     run under a different MMU setup which can cause cache problems,
  847.     if the other one writes to the same memory in copyback mode
  848.     while this task accesses the data in noncachable mode, for
  849.     example.
  850.  
  851.     The MMU support ist not implemented in powerpc.library <= V9.
  852.     The memory protection support ist not implemented in
  853.     powerpc.library <= V11.
  854.  
  855.     SEE ALSO
  856.     FreeVecPPC, FreeAllMem, powerpc/memoryPPC.i
  857.  
  858. powerpc.library/AllocXMsgPPC                      powerpc.library/AllocXMsgPPC
  859.  
  860.     NAME
  861.     AllocXMsgPPC - allocates a message for Inter-CPU communication (V12)
  862.  
  863.     CPU
  864.     PowerPC
  865.  
  866.     SYNOPSIS
  867.     message = AllocXMsgPPC(_PowerPCBase, bodysize, replyport)
  868.     r3                     r3            r4        r5
  869.  
  870.     struct Message *AllocXMsgPPC(struct Library *, ULONG, struct MsgPort *);
  871.  
  872.     FUNCTION
  873.     This function allocates memory for a message which can be used
  874.     for Inter-CPU communication. Some fields of the message are
  875.     initialized.
  876.     After this function was called, the message body must be
  877.     created before sending this message.
  878.  
  879.     INPUTS
  880.     _PowerPCBase - base of powerpc.library
  881.     bodysize - the size of the message body (max. 65535-MN_SIZE)
  882.     replyport - the reply port
  883.  
  884.     RESULT
  885.     message - The address of an initialized message (except for
  886.           the message body, which must be initialized by the
  887.           programmer).
  888.  
  889.     NOTES
  890.     Calling this function is the only way allowed to create a
  891.     message which can be sent to a 68K task.
  892.  
  893.     A message allocated with 'AllocXMsgPPC' should be freed using
  894.     'FreeXMsgPPC' if it is not used anymore.
  895.  
  896.     An Inter-CPU message must be sent with 'PutXMsgPPC' to a 68K
  897.     task.
  898.  
  899.     A replyport should always be specified. Inter-CPU messages
  900.     should always be replied and the reply should be read.
  901.  
  902.     It is possible not to specify a replyport (simply set
  903.     replyport to NULL). But don't forget that the message
  904.     must NOT be freed by a 68K task!
  905.  
  906.     SEE ALSO
  907.     FreeXMsgPPC, PutXMsgPPC
  908.  
  909. powerpc.library/AttemptSemaphorePPC        powerpc.library/AttemptSemaphorePPC
  910.  
  911.     NAME
  912.     AttemptSemaphorePPC - try to obtain without blocking (V8)
  913.  
  914.     CPU
  915.     PowerPC
  916.  
  917.     SYNOPSIS
  918.     status = AttemptSemaphorePPC(_PowerPCBase, SignalSemaphorePPC)
  919.                      r3            r4
  920.  
  921.     LONG AttemptSemaphorePPC(struct Library *,
  922.                   struct SignalSemaphorePPC *);
  923.  
  924.     FUNCTION
  925.     Tries to get exclusive access to a signal semaphore. If the semaphore
  926.     is locked by another task, this function returns with an appropriate
  927.     status value. This is the mirror function of exec/AttemptSemaphore
  928.  
  929.     INPUTS
  930.     _PowerPCBase - base of powerpc.library
  931.     SignalSemaphorePPC - pointer to a signalsemaphorePPC structure
  932.  
  933.     RESULT
  934.     status - status value:
  935.         ATTEMPT_SUCCESS: operation successful
  936.         ATTEMPT_FAILURE: semaphore couldn't be locked
  937.  
  938.     NOTES
  939.     This call is guaranteed to preserve all GPR (except r0 and r3)
  940.     and the CTR.
  941.  
  942.     SEE ALSO
  943.     InitSemaphorePPC, FreeSemaphorePPC, ObtainSemaphorePPC,
  944.     ReleaseSemaphorePPC, AddSemaphorePPC, RemSemaphorePPC
  945.     FindSemaphorePPC, powerpc/semaphoresPPC.i
  946.  
  947. powerpc.library/ChangeMMU                            powerpc.library/ChangeMMU
  948.  
  949.     NAME
  950.     ChangeMMU - changes the MMU setup of the current task (V10)
  951.  
  952.     CPU
  953.     PowerPC
  954.  
  955.     SYNOPSIS
  956.     ChangeMMU(_PowerPCBase, MMUMode)
  957.           r3            r4
  958.  
  959.     void ChangeMMU(struct Library *, ULONG);
  960.  
  961.     FUNCTION
  962.     Changes the MMU setup of the currently running task. A task is able
  963.     to run with two different MMU setups:
  964.  
  965.     - paged MMU setup: The standard method, where almost every memory
  966.       access is controlled by the page table
  967.     - BAT MMU setup: Almost all the memory is controlled by the 4 BAT
  968.       registers.
  969.  
  970.     INPUTS
  971.     _PowerPCBase - base of powerpc.library
  972.     MMUMode - CHMMU_STANDARD: change MMU setup to standard
  973.           CHMMU_BAT     : change MMU setup to BAT setup
  974.  
  975.     NOTES
  976.     This function should usually NOT be called. It is intended for
  977.     highly optimizing code and should only be used, if enough MMU
  978.     knowledge is present.
  979.  
  980.     The state of the current task can be changed from the shell by
  981.     using the tool 'changemmu' (and this is the better way how to
  982.     change the setup rather than calling the library function)
  983.  
  984.     SEE ALSO
  985.     powerpc/tasksppc.i
  986.  
  987. powerpc.library/ClearExcMMU                        powerpc.library/ClearExcMMU
  988.  
  989.     NAME
  990.     ClearExcMMU - removes the temp. MMU setup installed by SetExcMMU (V10)
  991.  
  992.     CPU
  993.     PowerPC
  994.  
  995.     SYNOPSIS
  996.     ClearExcMMU(_PowerPCBase)
  997.             r3
  998.  
  999.     void ClearExcMMU(struct Library *);
  1000.  
  1001.     FUNCTION
  1002.     This function is for exception handlers only. It removes the temporary
  1003.     BAT based MMU setup, which was installed using SetExcMMU. The old MMU
  1004.     state is restored.
  1005.  
  1006.     INPUTS
  1007.     _PowerPCBase - base of powerpc.library
  1008.  
  1009.     NOTES
  1010.     This function must not be called from anywhere else than from
  1011.     an exception handler.
  1012.  
  1013.     SEE ALSO
  1014.     SetExcMMU
  1015.  
  1016. powerpc.library/CmpTimePPC                          powerpc.library/CmpTimePPC
  1017.  
  1018.     NAME
  1019.     CmpTimePPC - compares two timeval structures (V7)
  1020.  
  1021.     CPU
  1022.     PowerPC
  1023.  
  1024.     SYNOPSIS
  1025.     result = CmpTimePPC(_PowerPCBase, Dest, Source)
  1026.     r3                  r3            r4    r5
  1027.  
  1028.     LONG CmpTimePPC(struct Library *, struct timeval *, struct timeval *);
  1029.  
  1030.     FUNCTION
  1031.     This routine compares two timeval structures.
  1032.  
  1033.     This is the mirror function of timer/CmpTime.
  1034.  
  1035.     INPUTS
  1036.     _PowerPCBase - base of powerpc.library
  1037.     Dest - pointer to a timeval structure
  1038.     Source - pointer to a timeval structure
  1039.  
  1040.     RESULT
  1041.     0  - if both timeval structures are equal
  1042.     -1 - if Dest is greater than Source
  1043.     1  - if Dest is less than Source
  1044.  
  1045.  
  1046.     NOTES
  1047.     This function is safe to call from exception handlers
  1048.  
  1049.     SEE ALSO
  1050.     GetSysTimePPC, AddTimePPC, SubTimePPC
  1051.  
  1052. powerpc.library/CopyMemPPC                          powerpc.library/CopyMemPPC
  1053.  
  1054.     NAME
  1055.     CopyMemPPC - copies memory the fastest way possible (V12)
  1056.  
  1057.     CPU
  1058.     PowerPC
  1059.  
  1060.     SYNOPSIS
  1061.     CopyMemPPC(_PowerPCBase, source, dest, size)
  1062.            r3            r4      r5    r6
  1063.  
  1064.     void CopyMemPPC(struct Library *, void *, void *, ULONG);
  1065.  
  1066.     FUNCTION
  1067.     This function copies a source memory area to a destination memory
  1068.     area. No overlapping is supported. CopyMemPPC tries to copy with
  1069.     the highest bandwidth possible.
  1070.  
  1071.     INPUTS
  1072.     _PowerPCBase - base of powerpc.library
  1073.     source - address of the source memory area
  1074.     dest - address of the destination memory area
  1075.     size - size of the memory area to be copied
  1076.  
  1077.     NOTES
  1078.     The highest performance can be achieved if both memory areas have
  1079.     a minimal alignment of 8.
  1080.  
  1081. powerpc.library/CreateMsgPortPPC              powerpc.library/CreateMsgPortPPC
  1082.  
  1083.     NAME
  1084.     CreateMsgPortPPC - creates a new PPC message port (V11)
  1085.  
  1086.     CPU
  1087.     PowerPC
  1088.  
  1089.     SYNOPSIS
  1090.     MsgPortPPC = CreateMsgPortPPC(_PowerPCBase)
  1091.     r3                            r3
  1092.  
  1093.     struct MsgPortPPC *CreateMsgPortPPC(struct Library *);
  1094.  
  1095.     FUNCTION
  1096.     This function creates a new PowerPC message port. This is the only
  1097.     way allowed to create a PPC message port. It is the mirror function
  1098.     of exec/CreateMsgPort.
  1099.  
  1100.     INPUTS
  1101.     _PowerPCBase - base of powerpc.library
  1102.  
  1103.     RESULT
  1104.     MsgPortPPC - pointer to a MsgPortPPC structure or NULL for failure
  1105.  
  1106.     NOTES
  1107.     A PowerPC message port should be deleted using 'DeleteMsgPortPPC'
  1108.     if it is not used anymore.
  1109.  
  1110.     It's forbidden to access PPC message ports by the standard
  1111.     exec message handling routines.
  1112.  
  1113.     SEE ALSO
  1114.     DeleteMsgPortPPC,FindPortPPC,AddPortPPC,RemPortPPC
  1115.     powerpc/portsPPC.i
  1116.  
  1117. powerpc.library/CreateTaskPPC                    powerpc.library/CreateTaskPPC
  1118.  
  1119.     NAME
  1120.     CreateTaskPPC - creates a new PPC task (V8)
  1121.  
  1122.     CPU
  1123.     PowerPC
  1124.  
  1125.     SYNOPSIS
  1126.     TaskPPC = CreateTaskPPC(_PowerPCBase, TagItems)
  1127.     r3                      r3            r4
  1128.  
  1129.     struct TaskPPC *CreateTaskPPC(struct Library *, struct TagItem *);
  1130.  
  1131.     FUNCTION
  1132.     This function creates a new PPC task under control of the tags passed.
  1133.     All memory (inclusive stack) is allocated automatically.
  1134.  
  1135.     PPC tasks are similar to exec tasks (the first element of the TaskPPC
  1136.     structure is an exec task structure). The scheduling of these tasks
  1137.     works similar to exec, so a running task blocks all tasks with lower
  1138.     priority.
  1139.  
  1140.     INPUTS
  1141.     _PowerPCBase - base of powerpc.library
  1142.     TagItems - pointer to a tagitem array. The following tags are
  1143.            supported:
  1144.  
  1145.         TASKATTR_CODE:      pointer to the entry point of the new task
  1146.                 (MUST be specified)
  1147.         TASKATTR_EXITCODE:  pointer to the exit routine of the new task
  1148.         TASKATTR_NAME:      task name (MUST be specified)
  1149.         TASKATTR_PRI:       task priority (-128 ... 127). Default = 0.
  1150.         TASKATTR_STACKSIZE: the desired stack size. If this tag is omitted
  1151.                 the default stack size will be 16K.
  1152.         TASKATTR_R2:        smalldata base of the PPC program
  1153.         TASKATTR_R3:
  1154.         ...
  1155.         TASKATTR_R10:       parameters to be passed to the new task
  1156.                 in the specified registers
  1157.         TASKATTR_MOTHERPRI: the priority is taken from the currently
  1158.                 running task (TASKATTR_PRI is ignored) (V9)
  1159.         TASKATTR_BAT:       lets the task run under BAT MMU setup by
  1160.                 default (V10)
  1161.  
  1162.     RESULT
  1163.     TaskPPC - pointer to a TaskPPC structure or NULL for failure
  1164.  
  1165.     NOTES
  1166.     If a 68K application only wants to call a PPC function, it's
  1167.     better to use Run68K instead of creating a new PPC task.
  1168.  
  1169.     While a PPC task created by Run68K is always connected to
  1170.     the calling 68K process, a task created by CreateTaskPPC is
  1171.     completely independent. If such a task peforms 68K calls, a
  1172.     new mirror process on the 68K side is created.
  1173.  
  1174.     If an alternative exit code is specified (TASKATTR_EXITCODE)
  1175.     the value passed in TASKATTR_R2 remains intact in this exit
  1176.     code.
  1177.  
  1178.     SEE ALSO
  1179.     DeleteTaskPPC,FindTaskPPC,powerpc/tasksPPC.i
  1180.  
  1181. powerpc.library/DeleteMsgPortPPC              powerpc.library/DeleteMsgPortPPC
  1182.  
  1183.     NAME
  1184.     DeleteMsgPortPPC - deletes a PPC message port (V11)
  1185.  
  1186.     CPU
  1187.     PowerPC
  1188.  
  1189.     SYNOPSIS
  1190.     DeleteMsgPortPPC(_PowerPCBase, MsgPortPPC)
  1191.              r3            r4
  1192.  
  1193.     void DeleteMsgPortPPC(struct Library *, struct MsgPortPPC *);
  1194.  
  1195.     FUNCTION
  1196.     This function deletes a PowerPC message port created using
  1197.     'CreateMsgPortPPC'. It is the mirror function of exec/DeleteMsgPort.
  1198.  
  1199.     INPUTS
  1200.     _PowerPCBase - base of powerpc.library
  1201.     MsgPortPPC - Pointer to the message port to delete. It's safe to
  1202.              pass NULL as parameter
  1203.  
  1204.     NOTES
  1205.     Calling 'DeleteMsgPortPPC' is the ONLY way allowed to delete a PPC
  1206.     message port.
  1207.  
  1208.     SEE ALSO
  1209.     CreateMsgPortPPC,FindPortPPC,AddPortPPC,RemPortPPC
  1210.     powerpc/portsPPC.i
  1211.  
  1212. powerpc.library/DeleteTaskPPC                    powerpc.library/DeleteTaskPPC
  1213.  
  1214.     NAME
  1215.     DeleteTaskPPC - deletes a PPC task (V8)
  1216.  
  1217.     CPU
  1218.     PowerPC
  1219.  
  1220.     SYNOPSIS
  1221.     DeleteTaskPPC(_PowerPCBase, PPCTask)
  1222.               r3            r4
  1223.  
  1224.     void DeleteTaskPPC(struct Library *, struct TaskPPC *);
  1225.  
  1226.     FUNCTION
  1227.     Deletes a PPC task created by CreateTaskPPC.
  1228.  
  1229.     INPUTS
  1230.     _PowerPCBase - base of powerpc.library
  1231.     TaskPPC - PPC task to remove or NULL for self removal
  1232.  
  1233.     NOTES
  1234.     It's not encouraged to delete other tasks. This function
  1235.     should only be called with a NULL parameter to remove the
  1236.     calling task itself.
  1237.  
  1238.     The system may also remove an existing 68K mirror process
  1239.     connected to the calling PPC task.
  1240.  
  1241.     SEE ALSO
  1242.     CreateTaskPPC,FindTaskPPC,powerpc/tasksPPC.i
  1243.  
  1244. powerpc.library/EndSnoopTask                      powerpc.library/EndSnoopTask
  1245.  
  1246.     NAME
  1247.     EndSnoopTask - stops monitoring a PPC task (V13)
  1248.  
  1249.     CPU
  1250.     PowerPC
  1251.  
  1252.     SYNOPSIS
  1253.     EndSnoopTask (_PowerPCBase, SnoopID)
  1254.               r3            r4
  1255.  
  1256.     void EndSnoopTask (struct Library *, ULONG);
  1257.  
  1258.     FUNCTION
  1259.     This function removes a callback job, which was installed using
  1260.     powerpc/SnoopTask.
  1261.  
  1262.     INPUTS
  1263.     _PowerPCBase - base of powerpc.library
  1264.     SnoopID - The value returned by SnoopTask. It's safe to pass
  1265.           NULL as parameter (is handled as no-op)
  1266.  
  1267.     SEE ALSO
  1268.     SnoopTask
  1269.  
  1270. powerpc.library/EnqueuePPC                          powerpc.library/EnqueuePPC
  1271.  
  1272.     NAME
  1273.     EnqueuePPC - inserts a node into a list sorted by priority (V8)
  1274.  
  1275.     CPU
  1276.     PowerPC
  1277.  
  1278.     SYNOPSIS
  1279.     EnqueuePPC(_PowerPCBase, list, node)
  1280.            r3            r4    r5
  1281.  
  1282.     void EnqueuePPC(struct Library *, struct List*, struct Node*);
  1283.  
  1284.     FUNCTION
  1285.     Inserts a node to a standard exec list based on the node priority.
  1286.     In this way a list can be kept sorted by priority all the time.
  1287.     New nodes will be inserted in front of the first node with a
  1288.     lower priority. This is the mirror function of exec/Enqueue.
  1289.  
  1290.     INPUTS
  1291.     _PowerPCBase - base of powerpc.library (can be omitted)
  1292.     list - a pointer to the target list
  1293.     node - the node to enqueue
  1294.  
  1295.     NOTES
  1296.     This function is guaranteed to work correctly, if the PowerPCBase
  1297.     is not passed in r3.
  1298.  
  1299.     This function is safe to call from exception handlers.
  1300.  
  1301.     SEE ALSO
  1302.     InsertPPC, AddTailPPC, AddHeadPPC, RemovePPC, RemHeadPPC,
  1303.     RemTailPPC, FindNamePPC, powerpc/listsPPC.i
  1304.  
  1305. powerpc.library/FindNamePPC                        powerpc.library/FindNamePPC
  1306.  
  1307.     NAME
  1308.     FindNamePPC - finds a node with given name (V8)
  1309.  
  1310.     CPU
  1311.     PowerPC
  1312.  
  1313.     SYNOPSIS
  1314.     node = FindNamePPC(_PowerPCBase, start, name)
  1315.     r3                 r3            r4     r5
  1316.  
  1317.     struct Node *FindNamePPC(struct Library *, struct List*, STRPTR);
  1318.  
  1319.     FUNCTION
  1320.     Searches a list for a node with the given name. If multiple nodes
  1321.     with same names should be found, this function can be called with
  1322.     a node starting point.
  1323.  
  1324.     INPUTS
  1325.     _PowerPCBase - base of powerpc.library
  1326.     list - a list header or a node to start the searche (if node,
  1327.            this one is skipped)
  1328.     name - the name of the node
  1329.  
  1330.     NOTES
  1331.     This function is guaranteed to work correctly, if the PowerPCBase
  1332.     is not passed in r3.
  1333.  
  1334.     This function is safe to call from exception handlers.
  1335.  
  1336.     SEE ALSO
  1337.     InsertPPC, AddTailPPC, AddHeadPPC, RemovePPC, RemHeadPPC,
  1338.     RemTailPPC, EnqueuePPC, powerpc/listsPPC.i
  1339.  
  1340. powerpc.library/FindPortPPC                        powerpc.library/FindPortPPC
  1341.  
  1342.     NAME
  1343.     FindPortPPC - finds a public PPC message port by name (V11)
  1344.  
  1345.     CPU
  1346.     PowerPC
  1347.  
  1348.     SYNOPSIS
  1349.     MsgPortPPC = FindPortPPC(_PowerPCBase, name)
  1350.     r3                       r3            r4
  1351.  
  1352.     struct MsgPortPPC* FindPortPPC(struct Library *, STRPTR);
  1353.  
  1354.     FUNCTION
  1355.     This function will search the global list of PPC message ports
  1356.     for a port with the given name. No arbritation is needed. This
  1357.     is the mirror function of exec/FindPort.
  1358.  
  1359.     INPUTS
  1360.     _PowerPCBase - base of powerpc.library
  1361.     name - name of the PPC message port to search
  1362.  
  1363.     RESULT
  1364.     MsgPortPPC - pointer to a PPC message port or NULL if it was not
  1365.              found.
  1366.  
  1367.     SEE ALSO
  1368.     CreateMsgPortPPC,DeleteMsgPortPPC,AddPortPPC,RemPortPPC
  1369.     powerpc/portsPPC.i
  1370.  
  1371. powerpc.library/FindSemaphorePPC              powerpc.library/FindSemaphorePPC
  1372.  
  1373.     NAME
  1374.     FindSemaphorePPC - finds a public semaphore (V8)
  1375.  
  1376.     CPU
  1377.     PowerPC
  1378.  
  1379.     SYNOPSIS
  1380.     SignalsemaphorePPC = FindSemaphorePPC(_PowerPCBase, SemaphoreName)
  1381.     r3                                    r3            r4
  1382.  
  1383.     struct signalsemaphorePPC *FindSemaphorePPC(struct Library *, STRPTR);
  1384.  
  1385.     FUNCTION
  1386.     Finds a public semaphore added to the system semaphore list by
  1387.     AddSemaphore. This is the mirror function to exec/FindSemaphore.
  1388.  
  1389.     INPUTS
  1390.     _PowerPCBase - base of powerpc.library
  1391.     SemaphoreName - name of the semaphore to find
  1392.  
  1393.     RESULT
  1394.     SignalsemaphorePPC - signal semaphore requested or 0 if it was not
  1395.                  found
  1396.  
  1397.     SEE ALSO
  1398.     InitSemaphorePPC, FreeSemaphorePPC, ObtainSemaphorePPC,
  1399.     AttemptSemaphorePPC, ReleaseSemaphorePPC, AddSemaphorePPC,
  1400.     RemSemaphorePPC, powerpc/semaphoresPPC.i
  1401.  
  1402. powerpc.library/FindTagItemPPC                  powerpc.library/FindTagItemPPC
  1403.  
  1404.     NAME
  1405.     FindTagItemPPC - scan a tag list for a specific tag (V8)
  1406.  
  1407.     CPU
  1408.     PowerPC
  1409.  
  1410.     SYNOPSIS
  1411.     tag = FindTagItemPPC(_PowerPCBase, tagValue, tagList)
  1412.     r3                   r3            r4        r5
  1413.  
  1414.     struct TagItem *FindTagItemPPC(struct Library *, ULONG,
  1415.                        struct TagItem *);
  1416.  
  1417.     FUNCTION
  1418.     Scans a tag list and returns a pointer to the first item with
  1419.     ti_Tag matching the 'tagValue' parameter. This is the mirror
  1420.     function of utility/FindTagItem.
  1421.  
  1422.     INPUTS
  1423.     _PowerPCBase - base of powerpc.library
  1424.     tagValue - tag value to search for
  1425.     tagList - tag item list to search (may be NULL)
  1426.  
  1427.     RESULT
  1428.     tag - a pointer to the item with ti_Tag matching 'tagValue'
  1429.           or NULL if no match was found.
  1430.  
  1431.     NOTES
  1432.     This function is safe to call from exception handlers.
  1433.  
  1434.     SEE ALSO
  1435.     GetTagDataPPC, NextTagItemPPC, utility/tagitem.i
  1436.  
  1437. powerpc.library/FindTaskPPC                    powerpc.library/FindTaskPPC
  1438.  
  1439.     NAME
  1440.     FindTaskPPC - finds a task by name (or find oneself) (V8)
  1441.  
  1442.     CPU
  1443.     PowerPC
  1444.  
  1445.     SYNOPSIS
  1446.     TaskPPC = FindTaskPPC(_PowerPCBase, Name)
  1447.     r3                    r3            r4
  1448.  
  1449.     struct TaskPPC *FindTaskPPC(struct Library *, STRPTR);
  1450.  
  1451.     FUNCTION
  1452.     Tries to find a task with the given name (or the current task if
  1453.     NULL is specified). This is the mirror function of exec/FindTask.
  1454.  
  1455.     INPUTS
  1456.     _PowerPCBase - base of powerpc.library
  1457.     Name - name of the task to find or NULL for the current task
  1458.  
  1459.     RESULT
  1460.     TaskPPC - pointer to the TaskPPC structure or NULL if the task
  1461.           was not found
  1462.  
  1463.     NOTES
  1464.     Be cautious that a task may be removed at any time, so the
  1465.     pointer returned may not be valid anymore when used.
  1466.  
  1467.     It's allowed to call FindTaskPPC with a NULL parameter from
  1468.     an exception handler. In this case the interrupted task is
  1469.     returned.
  1470.  
  1471.     SEE ALSO
  1472.     CreateTaskPPC,DeleteTaskPPC,powerpc/tasksPPC.i
  1473.  
  1474. powerpc.library/FreeAllMem                          powerpc.library/FreeAllMem
  1475.  
  1476.     NAME
  1477.     FreeAllMem - frees all memory allocated by the calling task (V11)
  1478.  
  1479.     CPU
  1480.     PowerPC
  1481.  
  1482.     SYNOPSIS
  1483.     FreeAllMem(_PowerPCBase)
  1484.            r3
  1485.  
  1486.     void FreeVecPPC(struct Library *);
  1487.  
  1488.     FUNCTION
  1489.     Frees all memory which was allocated by the calling task. This is an
  1490.     easy way to free the memory rather than calling FreeVecPPC for every
  1491.     allocation made.
  1492.  
  1493.     INPUTS
  1494.     _PowerPCBase - base of powerpc.library
  1495.  
  1496.     SEE ALSO
  1497.     AllocVecPPC,FreeVecPPC,powerpc/memoryPPC.i
  1498.  
  1499. powerpc.library/FreeSemaphorePPC              powerpc.library/FreeSemaphorePPC
  1500.  
  1501.     NAME
  1502.     FreeSemaphorePPC - frees a signal semaphore (V8)
  1503.  
  1504.     CPU
  1505.     PowerPC
  1506.  
  1507.     SYNOPSIS
  1508.     FreeSemaphorePPC(_PowerPCBase, SignalSemaphorePPC)
  1509.              r3            r4
  1510.  
  1511.     void FreeSemaphorePPC(struct Library *, struct SignalSemaphorePPC *);
  1512.  
  1513.     FUNCTION
  1514.     Frees a signal semaphore initialized by InitSemaphorePPC. There
  1515.     is no similar function in exec.library!
  1516.  
  1517.     INPUTS
  1518.     _PowerPCBase - base of powerpc.library
  1519.     SignalSemaphorePPC - pointer to a signalsemaphorePPC structure
  1520.  
  1521.     SEE ALSO
  1522.     InitSemaphorePPC, ObtainSemaphorePPC, AttemptSemaphorePPC,
  1523.     ReleaseSemaphorePPC, AddSemaphorePPC, RemSemaphorePPC,
  1524.     FindSemaphorePPC, powerpc/semaphoresPPC.i
  1525.  
  1526. powerpc.library/FreeSignalPPC                    powerpc.library/FreeSignalPPC
  1527.  
  1528.     NAME
  1529.     FreeSignalPPC - frees a signal (V8)
  1530.  
  1531.     CPU
  1532.     PowerPC
  1533.  
  1534.     SYNOPSIS
  1535.     FreeSignalPPC(_PowerPCBase, signalNum)
  1536.               r3            r4
  1537.  
  1538.     void FreeSignalPPC(struct Library *, LONG);
  1539.  
  1540.     FUNCTION
  1541.     Frees a signal bit allocated by AllocSignalPPC. This is the
  1542.     mirror function of exec/FreeSignal.
  1543.  
  1544.     INPUTS
  1545.     _PowerPCBase - base of powerpc.library
  1546.     signalNum - the signal bit number to free (0..31). It's
  1547.             safe to pass -1 as input parameter.
  1548.  
  1549.     SEE ALSO
  1550.     AllocSignalPPC, SetSignalPPC, SignalPPC, WaitPPC
  1551.  
  1552. powerpc.library/FreeVecPPC                          powerpc.library/FreeVecPPC
  1553.  
  1554.     NAME
  1555.     FreeVecPPC - frees memory allocated by AllocVecPPC (V7)
  1556.  
  1557.     CPU
  1558.     PowerPC
  1559.  
  1560.     SYNOPSIS
  1561.     status = FreeVecPPC(_PowerPCBase, memblock)
  1562.     r3                  r3            r4
  1563.  
  1564.     LONG FreeVecPPC(struct Library *, void *);
  1565.  
  1566.     FUNCTION
  1567.     Frees memory allocated by AllocVecPPC. This is the mirror function
  1568.     of exec/FreeVec.
  1569.  
  1570.     INPUTS
  1571.     _PowerPCBase - base of powerpc.library
  1572.     memblock - address of memory to be freed. It's safe to pass NULL
  1573.            as input parameter.
  1574.  
  1575.     RESULT
  1576.     status - a status value:
  1577.         MEMERR_SUCCESS - operation was successful
  1578.  
  1579.     SEE ALSO
  1580.     AllocVecPPC, FreeAllMem, powerpc/memoryPPC.i
  1581.  
  1582. powerpc.library/FreeXMsgPPC                        powerpc.library/FreeXMsgPPC
  1583.  
  1584.     NAME
  1585.     FreeXMsgPPC - frees a message allocated with 'AllocXMsgPPC' (V12)
  1586.  
  1587.     CPU
  1588.     PowerPC
  1589.  
  1590.     SYNOPSIS
  1591.     FreeXMsgPPC(_PowerPCBase, message)
  1592.              r3           r4
  1593.  
  1594.     void FreeXMsgPPC(struct Library *, struct Message *);
  1595.  
  1596.     FUNCTION
  1597.     This function frees a memory allocated using 'AllocXMsgPPC'.
  1598.  
  1599.     INPUTS
  1600.     _PowerPCBase - base of powerpc.library
  1601.     message - a message allocated by 'AllocXMsgPPC'.
  1602.  
  1603.     NOTES
  1604.     [An Inter-CPU message must not be freed, if it was sent to
  1605.     a 68K task and the reply has not yet arrived back.]
  1606.  
  1607.     The above statement is not valid anymore. Inter-CPU-Messages
  1608.     can be freed by another 68K task even if it wasn't replied.
  1609.  
  1610.     SEE ALSO
  1611.     AllocXMsgPPC, PutXMsgPPC
  1612.  
  1613. powerpc.library/GetInfo                                powerpc.library/GetInfo
  1614.  
  1615.     NAME
  1616.     GetInfo - evaluates many CPU related information (V10)
  1617.  
  1618.     CPU
  1619.     PowerPC
  1620.  
  1621.     SYNOPSIS
  1622.     GetInfo(_PowerPCBase, PPCInfoTagList)
  1623.         r3            r4
  1624.  
  1625.     void GetInfo(struct Library *, struct TagItem *);
  1626.  
  1627.     FUNCTION
  1628.     This function is able to evaluate many CPU related information
  1629.     such as CPU type, cache states and more. The values which should
  1630.     be evaluated are specified using the appropriate tags (defined
  1631.     in powerpc/powerpc.i) and the value is returned in the appropriate
  1632.     ti_Data field.
  1633.  
  1634.     INPUTS
  1635.     _PowerPCBase - base of powerpc.library
  1636.     PPCInfoTagList - pointer to a tagitem array. The following tags are
  1637.              supported:
  1638.         PPCINFO_CPU:        evaluates the PowerPC CPU type (see powerpc/
  1639.                 powerpc.i for a description of the possible
  1640.                 return values)
  1641.         PPCINFO_PVR:        returns the PVR register which also contains
  1642.                 the revision number of the CPU besides the
  1643.                 CPU type.
  1644.         PPCINFO_ICACHE:     returns the state of the instruction cache
  1645.                 See powerpc/powerpc.i for a description of
  1646.                 the possible values.
  1647.         PPCINFO_DCACHE:     returns the state of the data cache. The
  1648.                 values possible are the same as for PPCINFO_
  1649.                 ICACHE.
  1650.         PPCINFO_PAGETABLE:  returns the location of the standard page table
  1651.         PPCINFO_TABLESIZE:  returns the size of the page table (in KBytes)
  1652.         PPCINFO_BUSCLOCK:   returns the bus clock value (in Hz)
  1653.         PPCINFO_CPUCLOCK:   returns the CPU clock value (in Hz)
  1654.  
  1655.     NOTES
  1656.     The CPU clock cannot be evaluated on PowerPC systems without the
  1657.     extension E (for example PPC603,PPC604) because the supervisor
  1658.     register HID1 is missing. In this case, 0 is returned.
  1659.  
  1660.     Usually the PPC-CPU's available for AMIGA will have this register
  1661.     (for example: PPC603E, PPC604E)
  1662.  
  1663.     SEE ALSO
  1664.     powerpc/powerpc.i
  1665.  
  1666. powerpc.library/GetMsgPPC                            powerpc.library/GetMsgPPC
  1667.  
  1668.     NAME
  1669.     GetMsgPPC - get next message from a message port (V11)
  1670.  
  1671.     CPU
  1672.     PowerPC
  1673.  
  1674.     SYNOPSIS
  1675.     message = GetMsgPPC(_PowerPCBase, MsgPortPPC)
  1676.     r3                  r3            r4
  1677.  
  1678.     struct Message *GetMsgPPC(struct Library *, struct MsgPortPPC *);
  1679.  
  1680.     FUNCTION
  1681.     This function receives a message from a given message port. This
  1682.     is the mirror function of exec/GetMsg.
  1683.  
  1684.     INPUTS
  1685.     _PowerPCBase - base of powerpc.library
  1686.     port - a pointer to a message port
  1687.  
  1688.     RESULTS
  1689.     message - a pointer to the first available message or NULL if none
  1690.           is available.
  1691.  
  1692.     SEE ALSO
  1693.     WaitPortPPC, PutMsgPPC, ReplyMsgPPC, powerpc/portsPPC.i
  1694.  
  1695. powerpc.library/GetSysTimePPC                    powerpc.library/GetSysTimePPC
  1696.  
  1697.     NAME
  1698.     GetSysTimePPC - get the current (relative) time (V7)
  1699.  
  1700.     CPU
  1701.     PowerPC
  1702.  
  1703.     SYNOPSIS
  1704.     GetSysTimePPC(_PowerPCBase, Dest )
  1705.                 r3      r4
  1706.  
  1707.     void GetSysTimePPC(struct Library *, struct timeval * );
  1708.  
  1709.     FUNCTION
  1710.     Returns the current system time. This time is NOT absolute, there
  1711.     is no relation between the real time and the time returned by
  1712.     GetSysTimePPC. This function can be used for measurement of
  1713.     time spans.
  1714.  
  1715.     This is the mirror function of timer/GetSysTime.
  1716.  
  1717.     INPUTS
  1718.     _PowerPCBase - base of powerpc.library
  1719.     Dest - pointer to a timeval structure (where the time is stored)
  1720.  
  1721.     NOTES
  1722.     This function has different behaviour on powerpc.library V7 and
  1723.     powerpc.library V8+.
  1724.  
  1725.     V7: The time is evaluated using the timer.device (via a cross
  1726.     call) because it isn't possible to evaluate the busclock frequency
  1727.     of the PPC with V7 (and ppc.library below) until now.
  1728.  
  1729.     V8+: The time is evaluated completely native (and fast) using the
  1730.     internal timers and the busclock frequency evaluated by WarpOS.
  1731.  
  1732.     This function is safe to call from exception handlers ONLY in
  1733.     powerpc.library V8 and higher !!
  1734.  
  1735.     SEE ALSO
  1736.     AddTimePPC, SubTimePPC, CmpTimePPC
  1737.  
  1738. powerpc.library/GetTagDataPPC                    powerpc.library/GetTagDataPPC
  1739.  
  1740.     NAME
  1741.     GetTagDataPPC - obtain the data corresponding to a tag (V8)
  1742.  
  1743.     CPU
  1744.     PowerPC
  1745.  
  1746.     SYNOPSIS
  1747.     value = GetTagDataPPC(_PowerPCBase, tagValue, defaultVal, tagList)
  1748.     r3                    r3            r4        r5          r6
  1749.  
  1750.     ULONG *GetTagDataPPC(struct Library *, ULONG, ULONG, struct TagItem* );
  1751.  
  1752.     FUNCTION
  1753.     Searches a tag list for a matching tag and returns the corresponding
  1754.     ti_Data value for the TagItem found. If no match is found,
  1755.     this function returns the value passed in as 'defaultVal'. This
  1756.     is the mirror function of utility/GetTagData.
  1757.  
  1758.     INPUTS
  1759.     _PowerPCBase - base of powerpc.library
  1760.     tagValue - tag value to search for
  1761.     defaultVal - value to be returned if tagValue is not found
  1762.     tagList - tag item list to search (may be NULL)
  1763.  
  1764.     RESULT
  1765.     value - the ti_Data value for the first matching TagItem, or
  1766.         'defaultVal' if a ti_Tag matching Tag is not found.
  1767.  
  1768.     NOTES
  1769.     This function is safe to call from exception handlers.
  1770.  
  1771.     SEE ALSO
  1772.     FindTagItemPPC, NextTagItemPPC, utility/tagitem.i
  1773.  
  1774. powerpc.library/InitSemaphorePPC              powerpc.library/InitSemaphorePPC
  1775.  
  1776.     NAME
  1777.     InitSemaphorePPC - initializes a signal semaphore (V8)
  1778.  
  1779.     CPU
  1780.     PowerPC
  1781.  
  1782.     SYNOPSIS
  1783.     status = InitSemaphorePPC(_PowerPCBase, SignalSemaphorePPC)
  1784.     r3                        r3            r4
  1785.  
  1786.     LONG InitSemaphorePPC(struct Library *, struct SignalSemaphorePPC *);
  1787.  
  1788.     FUNCTION
  1789.     Initializes a signal semaphore. This is the mirror function of
  1790.     exec/InitSemaphore with some changes.
  1791.  
  1792.     INPUTS
  1793.     _PowerPCBase - base of powerpc.library
  1794.     SignalSemaphorePPC - pointer to a signalsemaphorePPC structure
  1795.                  (all fields to zero)
  1796.  
  1797.     RESULT
  1798.     status - status value:
  1799.         SSPPC_SUCCESS: function was successful
  1800.         SSPPC_NOMEM: function failed due to lack of memory
  1801.  
  1802.     NOTES
  1803.     In opposite to exec/InitSemaphore a signal semaphore for PPC
  1804.     has to be freed with FreeSemaphorePPC, because InitSemaphorePPC
  1805.     allocates memory which should be freed after use.
  1806.  
  1807.     SEE ALSO
  1808.     FreeSemaphorePPC, ObtainSemaphorePPC, AttemptSemaphorePPC,
  1809.     ReleaseSemaphorePPC, AddSemaphorePPC, RemSemaphorePPC,
  1810.     FindSemaphorePPC, powerpc/semaphoresPPC.i
  1811.  
  1812. powerpc.library/InsertPPC                            powerpc.library/InsertPPC
  1813.  
  1814.     NAME
  1815.     InsertPPC - insert a node into a list (V8)
  1816.  
  1817.     CPU
  1818.     PowerPC
  1819.  
  1820.     SYNOPSIS
  1821.     Insert(_PowerPCBase, list, node, nodepredecessor)
  1822.            r3            r4    r5    r6
  1823.  
  1824.     void InsertPPC(struct Library *, struct List*, struct Node*,
  1825.                struct Node*);
  1826.  
  1827.     FUNCTION
  1828.     Insert a node into an standard exec list. This is the mirror
  1829.     function of exec/Insert.
  1830.  
  1831.     INPUTS
  1832.     _PowerPCBase - base of powerpc.library (can be omitted)
  1833.     list - a pointer to the target list
  1834.     node - the node to insert
  1835.     nodepredecessor - the node after which to insert. If 0 is passed,
  1836.               the node is inserted at the head of the list.
  1837.  
  1838.     NOTES
  1839.     This function is guaranteed to work correctly, if the PowerPCBase
  1840.     is not passed in r3.
  1841.  
  1842.     This function is safe to call from exception handlers.
  1843.  
  1844.     SEE ALSO
  1845.     AddHeadPPC, AddTailPPC, RemovePPC, RemHeadPPC, RemTailPPC,
  1846.     EnqueuePPC, FindNamePPC, powerpc/listsPPC.i
  1847.  
  1848. powerpc.library/LockTaskList                      powerpc.library/LockTaskList
  1849.  
  1850.     NAME
  1851.     LockTaskList - locks a list of all tasks (V10)
  1852.  
  1853.     CPU
  1854.     PowerPC
  1855.  
  1856.     SYNOPSIS
  1857.     TaskPtr = LockTaskList(_PowerPCBase)
  1858.     r3                     r3
  1859.  
  1860.     struct TaskPtr* LockTaskList(struct Library *);
  1861.  
  1862.     FUNCTION
  1863.     This function locks a list of all PPC tasks currently available.
  1864.     The main purpose of this function is to allow examining the
  1865.     PPCtask structures without to worry about protecting the access
  1866.     by semaphores (this is done internally).
  1867.  
  1868.     The usual method of accessing the task information is the
  1869.     following:
  1870.  
  1871.     - Lock the task list using 'LockTaskList'
  1872.     - Get the pointer to the first task (by reading out the entry
  1873.       TASKPTR_TASK of the returned TaskPtr structure)
  1874.     - Scan trough the list and read out all infomation you need until
  1875.       you find the end of the list
  1876.     - Unlock the list using 'UnLockTaskList'
  1877.  
  1878.     INPUTS
  1879.     _PowerPCBase - base of powerpc.library
  1880.  
  1881.     RESULTS
  1882.     TaskPtr - Ptr to the first node of a list of TaskPtr structures
  1883.           (see powerpc/tasksppc.i)
  1884.  
  1885.     NOTES
  1886.     The WarpOS multitasking is NOT halted between LockTaskList and
  1887.     UnLockTaskList.
  1888.  
  1889.     No new tasks are created and no resources of removed tasks are
  1890.     freed between LockTaskList and UnLockTaskList. So don't lock the
  1891.     list for a too long time.
  1892.  
  1893.     SEE ALSO
  1894.     UnLockTaskList, powerpc/tasksppc.i
  1895.  
  1896. powerpc.library/ModifyFPExc                        powerpc.library/ModifyFPExc
  1897.  
  1898.     NAME
  1899.     ModifyFPExc - enables/disables specific floating point exceptions (V9)
  1900.  
  1901.     CPU
  1902.     PowerPC
  1903.  
  1904.     SYNOPSIS
  1905.     ModifyFPExc(_PowerPCBase, FPflags)
  1906.             r3            r4
  1907.  
  1908.     void ModifyFPExc(struct Library *, ULONG);
  1909.  
  1910.     FUNCTION
  1911.     This function allows to enable/disable particular floating
  1912.     point exceptions. Multiple exceptions can be affected
  1913.     simultaneously.
  1914.  
  1915.     INPUTS
  1916.     _PowerPCBase - base of powerpc.library
  1917.     FPflags - action to be performed:
  1918.         FPF_EN_OVERFLOW:    Enables FP overflow exception
  1919.         FPF_EN_UNDERFLOW:   Enables FP underflow exception
  1920.         FPF_EN_ZERODIVIDE:  Enables FP zero divide exception
  1921.         FPF_EN_INEXACT:     Enables FP inexact operation exception
  1922.         FPF_EN_INVALID:     Enables FP invalid operation exception
  1923.         FPF_DIS_OVERFLOW:   Disables FP overflow exception
  1924.         FPF_DIS_UNDERFLOW:  Disables FP underflow exception
  1925.         FPF_DIS_ZERODIVIDE: Disables FP zero divide exception
  1926.         FPF_DIS_INEXACT:    Disables FP inexact operation exception
  1927.         FPF_DIS_INVALID:    Disables FP invalid operation exception
  1928.  
  1929.     NOTES
  1930.     Floating point exceptions must be enabled globally using 'SetHardware'
  1931.     otherwise this function doesn't have any effect.
  1932.  
  1933.     SEE ALSO
  1934.     SetHardware, powerpc/powerpc.i
  1935.  
  1936. powerpc.library/NextTagItemPPC                  powerpc.library/NextTagItemPPC
  1937.  
  1938.     NAME
  1939.     NextTagItemPPC - iterate through a tag list (V8)
  1940.  
  1941.     CPU
  1942.     PowerPC
  1943.  
  1944.     SYNOPSIS
  1945.     tag = NextTagItemPPC(_PowerPCBase, tagItemPtr)
  1946.     r3                   r3            r4
  1947.  
  1948.     struct TagItem *NextTagItemPPC(struct Library *, struct TagItem **);
  1949.  
  1950.     FUNCTION
  1951.     Iterates through a tag list, skipping and chaining as dictated by
  1952.     system tags. Each call returns either the next item to be examined
  1953.     or NULL when the end of the list has benn reached. This is the
  1954.     mirror function of utility/NextTagItem.
  1955.  
  1956.     INPUTS
  1957.     _PowerPCBase - base of powerpc.library
  1958.     tagItemPtr - double-indirect reference to a TagItem structure.
  1959.              The pointer will be changed to keep track of the
  1960.              iteration.
  1961.  
  1962.     RESULT
  1963.     tag - each TagItem in the array that should be processed is
  1964.           returned in turn with succesive calls.
  1965.  
  1966.     NOTES
  1967.     This function is safe to call from exception handlers.
  1968.  
  1969.     SEE ALSO
  1970.     FindTagItemPPC, GetTagDataPPC, utility/tagitem.i
  1971.  
  1972. powerpc.library/ObtainSemaphorePPC          powerpc.library/ObtainSemaphorePPC
  1973.  
  1974.     NAME
  1975.     ObtainSemaphorePPC - gain exclusive access to a semaphore (V8)
  1976.  
  1977.     CPU
  1978.     PowerPC
  1979.  
  1980.     SYNOPSIS
  1981.     ObtainSemaphorePPC(_PowerPCBase, SignalSemaphorePPC)
  1982.                r3            r4
  1983.  
  1984.     void ObtainSemaphorePPC(struct Library *, struct SignalSemaphorePPC *);
  1985.  
  1986.     FUNCTION
  1987.     Tries to get exclusive access to a signal semaphore. If the semaphore
  1988.     is occupied, the task adds itself into a waiting queue. This is the
  1989.     mirror function of exec/ObtainSemaphore.
  1990.  
  1991.     INPUTS
  1992.     _PowerPCBase - base of powerpc.library
  1993.     SignalSemaphorePPC - pointer to a signalsemaphorePPC structure
  1994.  
  1995.     NOTES
  1996.     This call is guaranteed to preserve all GPR (except r0) and the CTR.
  1997.  
  1998.     SEE ALSO
  1999.     InitSemaphorePPC, FreeSemaphorePPC, AttemptSemaphorePPC,
  2000.     ReleaseSemaphorePPC, AddSemaphorePPC, RemSemaphorePPC
  2001.     FindSemaphorePPC, powerpc/semaphoresPPC.i
  2002.  
  2003. powerpc.library/PutMsgPPC                            powerpc.library/PutMsgPPC
  2004.  
  2005.     NAME
  2006.     PutMsgPPC - put a message to a message port (V11)
  2007.  
  2008.     CPU
  2009.     PowerPC
  2010.  
  2011.     SYNOPSIS
  2012.     PutMsgPPC(_PowerPCBase, MsgPortPPC, message)
  2013.           r3            r4          r5
  2014.  
  2015.     void PutMsgPPC(struct Library *, struct MsgPortPPC *, struct Messge *);
  2016.  
  2017.     FUNCTION
  2018.     This function attaces a message to the end of the given port. In
  2019.     opposition to exec/PutMsg, only ports with PA_SIGNAL are supported.
  2020.     This is the mirror function of exec/PutMsg.
  2021.  
  2022.     INPUTS
  2023.     _PowerPCBase - base of powerpc.library
  2024.     port - a pointer to a message port
  2025.     message - a pointer to the message to be sent
  2026.  
  2027.     NOTES
  2028.     This function is safe to call from exception handlers.
  2029.  
  2030.     SEE ALSO
  2031.     WaitPortPPC, GetMsgPPC, ReplyMsgPPC, powerpc/portsPPC.i
  2032.  
  2033. powerpc.library/PutXMsgPPC                          powerpc.library/PutXMsgPPC
  2034.  
  2035.     NAME
  2036.     PutXMsgPPC - sends an Inter-CPU message to a 68K task (V12)
  2037.  
  2038.     CPU
  2039.     PowerPC
  2040.  
  2041.     SYNOPSIS
  2042.     PutXMsgPPC(_PowerPCBase, MsgPort, message)
  2043.            r3            r4       r5
  2044.  
  2045.     void PutXMsgPPC(struct Library *, struct MsgPort *, struct Message *);
  2046.  
  2047.     FUNCTION
  2048.     This function sends an Inter-CPU message allocated by 'AllocXMsgPPC'
  2049.     to a 68K task.
  2050.  
  2051.     INPUTS
  2052.     _PowerPCBase - base of powerpc.library
  2053.     MsgPort - an exec message port
  2054.     message - a message allocated by 'AllocXMsgPPC'.
  2055.  
  2056.     NOTES
  2057.     Inter-CPU must NOT be used for internal communication. They can
  2058.     only be used for communication between tasks on different processors.
  2059.  
  2060.     Inter-CPU messages get a different node type, if they are
  2061.     sent. If you want to filter out Reply-Messages from standard
  2062.     or Inter-CPU messages, compare the LN_TYPE field to NT_REPLYMSG.
  2063.     Replied Inter-CPU messages still get the same node type
  2064.     (NT_REPLYMSG). Any assumptions about the value of the new
  2065.     node type are ILLEGAL!!
  2066.  
  2067.     As soon as an Inter-CPU message is sent, the PPC looses ownership
  2068.     over the message. No access to the message is allowed until the
  2069.     reply has been arrived.
  2070.  
  2071.     Inter-CPU messages can be reused if they have been replied.
  2072.  
  2073.     Inter-CPU messages are read and replied using the standard
  2074.     message handling mechanisms (exec/WaitPort,exec/GetMsg,exec/ReplyMsg
  2075.     for 68K, powerpc/WaitPortPPC, powerpc/GetMsgPPC, powerpc/ReplyMsgPPC
  2076.     for PPC).
  2077.  
  2078.     The receiving task must NOT access message data, which are not
  2079.     explicitely located in the message body (for example data which is
  2080.     referenced by a pointer) unless both tasks care for the cache
  2081.     consistency. Only the message itself is flushed/invalidated
  2082.     automatically by the system.
  2083.  
  2084.     The receiving task may write to the message body of an Inter-CPU
  2085.     message.
  2086.  
  2087.     Inter-CPU messages should always be replied and the reply should
  2088.     be read and filtered out.
  2089.  
  2090.     SEE ALSO
  2091.     AllocXMsgPPC, FreeXMsgPPC
  2092.  
  2093. powerpc.library/ReleaseSemaphorePPC        powerpc.library/ReleaseSemaphorePPC
  2094.  
  2095.     NAME
  2096.     ReleaseSemaphorePPC - make signal semaphore available to others (V8)
  2097.  
  2098.     CPU
  2099.     PowerPC
  2100.  
  2101.     SYNOPSIS
  2102.     ReleaseSemaphorePPC(_PowerPCBase, SignalSemaphorePPC)
  2103.                 r3            r4
  2104.  
  2105.     void ReleaseSemaphorePPC(struct Library *,
  2106.                  struct SignalSemaphorePPC *);
  2107.  
  2108.     FUNCTION
  2109.     Releases a semaphore locked by either ObtainSemaphorePPC or
  2110.     AttemptSemaphorePPC. If other tasks are waiting, the foremost
  2111.     in the waiting queue is waked up.
  2112.  
  2113.     INPUTS
  2114.     _PowerPCBase - base of powerpc.library
  2115.     SignalSemaphorePPC - pointer to a signalsemaphorePPC structure
  2116.  
  2117.     NOTES
  2118.     This call is guaranteed to preserve all GPR (except r0) and the CTR.
  2119.  
  2120.     If the semaphore is in an illegal state after calling
  2121.     ReleaseSemaphorePPC, a system message will appear and the task is
  2122.     put into waiting state.
  2123.  
  2124.     SEE ALSO
  2125.     InitSemaphorePPC, FreeSemaphorePPC, ObtainSemaphorePPC,
  2126.     AttemptSemaphorePPC, AddSemaphorePPC, RemSemaphorePPC
  2127.     FindSemaphorePPC, powerpc/semaphoresPPC.i
  2128.  
  2129. powerpc.library/RemExcHandler                    powerpc.library/RemExcHandler
  2130.  
  2131.     NAME
  2132.     RemExcHandler - removes a custom exception handler (V9)
  2133.  
  2134.     CPU
  2135.     PowerPC
  2136.  
  2137.     SYNOPSIS
  2138.     RemExcHandler(_PowerPCBase, XLock)
  2139.               r3            r4
  2140.  
  2141.     void RemExcHandler(struct Library *, void *);
  2142.  
  2143.     FUNCTION
  2144.     Removes an exception handler inserted by the function SetExcHandler.
  2145.  
  2146.     INPUTS
  2147.     _PowerPCBase - base of powerpc.library
  2148.     XLock - The lock value returned by SetExcHandler. It's safe to pass
  2149.         NULL as parameter
  2150.  
  2151.     SEE ALSO
  2152.     RemExcHandler, powerpc/powerpc.i
  2153.  
  2154. powerpc.library/RemHeadPPC                          powerpc.library/RemHeadPPC
  2155.  
  2156.     NAME
  2157.     RemHeadPPC - removes the head node from a list (V8)
  2158.  
  2159.     CPU
  2160.     PowerPC
  2161.  
  2162.     SYNOPSIS
  2163.     node = RemHeadPPC(_PowerPCBase, list)
  2164.     r3                r3            r4
  2165.  
  2166.     struct Node *RemHeadPPC(struct Library *, struct List*);
  2167.  
  2168.     FUNCTION
  2169.     Removes the head node of a list. This is the mirror function of
  2170.     exec/RemHead.
  2171.  
  2172.     INPUTS
  2173.     _PowerPCBase - base of powerpc.library (can be omitted)
  2174.     list - the target list from which the head node should be removed
  2175.  
  2176.     RESULT
  2177.     node - the node removed or 0 if the list was empty
  2178.  
  2179.     NOTES
  2180.     This function is guaranteed to work correctly, if the PowerPCBase
  2181.     is not passed in r3.
  2182.  
  2183.     Assembler programmers may use the macro _REMHEAD located in
  2184.     'powerpc/listsPPC.i'
  2185.  
  2186.     This function is safe to call from exception handlers.
  2187.  
  2188.     SEE ALSO
  2189.     InsertPPC, AddTailPPC, AddHeadPPC, RemovePPC, RemTailPPC,
  2190.     EnqueuePPC, FindNamePPC, powerpc/listsPPC.i
  2191.  
  2192. powerpc.library/RemovePPC                            powerpc.library/RemovePPC
  2193.  
  2194.     NAME
  2195.     RemovePPC - removes a node from a list (V8)
  2196.  
  2197.     CPU
  2198.     PowerPC
  2199.  
  2200.     SYNOPSIS
  2201.     RemovePPC(_PowerPCBase, node)
  2202.            r3           r4
  2203.  
  2204.     void RemovePPC(struct Library *, struct Node*);
  2205.  
  2206.     FUNCTION
  2207.     Removes a node from whatever list it is in. This is the mirror
  2208.     function of exec/Remove.
  2209.  
  2210.     INPUTS
  2211.     _PowerPCBase - base of powerpc.library (can be omitted)
  2212.     node - the node to remove
  2213.  
  2214.     NOTES
  2215.     This function is guaranteed to work correctly, if the PowerPCBase
  2216.     is not passed in r3.
  2217.  
  2218.     Assembler programmers may use the macro _REMOVE located in
  2219.     'powerpc/listsPPC.i'
  2220.  
  2221.     This function is safe to call from exception handlers.
  2222.  
  2223.     SEE ALSO
  2224.     InsertPPC, AddTailPPC, AddHeadPPC, RemHeadPPC, RemTailPPC,
  2225.     EnqueuePPC, FindNamePPC, powerpc/listsPPC.i
  2226.  
  2227. powerpc.library/RemPortPPC                          powerpc.library/RemPortPPC
  2228.  
  2229.     NAME
  2230.     RemPortPPC - removes a public PPC message port from the system (V11)
  2231.  
  2232.     CPU
  2233.     PowerPC
  2234.  
  2235.     SYNOPSIS
  2236.     RemPortPPC(_PowerPCBase, MsgPortPPC)
  2237.            r3            r4
  2238.  
  2239.     void RemPortPPC(struct Library *, struct MsgPortPPC *);
  2240.  
  2241.     FUNCTION
  2242.     This function removes a public message port from the global list
  2243.     of message ports. It is the mirror function of exec/RemPort.
  2244.  
  2245.     INPUTS
  2246.     _PowerPCBase - base of powerpc.library
  2247.     MsgPortPPC - pointer to a PPC message port. It's safe to pass a NULL
  2248.              parameter.
  2249.  
  2250.     SEE ALSO
  2251.     CreateMsgPortPPC,DeleteMsgPortPPC,FindPortPPC,AddPortPPC
  2252.     powerpc/portsPPC.i
  2253.  
  2254. powerpc.library/RemTailPPC                          powerpc.library/RemTailPPC
  2255.  
  2256.     NAME
  2257.     RemTailPPC - removes the tail node from a list (V8)
  2258.  
  2259.     CPU
  2260.     PowerPC
  2261.  
  2262.     SYNOPSIS
  2263.     node = RemTailPPC(_PowerPCBase, list)
  2264.     r3                r3            r4
  2265.  
  2266.     struct Node *RemTailPPC(struct Library *, struct List*);
  2267.  
  2268.     FUNCTION
  2269.     Removes the tail node of a list. This is the mirror function of
  2270.     exec/RemTail.
  2271.  
  2272.     INPUTS
  2273.     _PowerPCBase - base of powerpc.library (can be omitted)
  2274.     list - the target list from which the tail node should be removed
  2275.  
  2276.     RESULT
  2277.     node - the node removed or 0 if the list was empty
  2278.  
  2279.     NOTES
  2280.     This function is guaranteed to work correctly, if the PowerPCBase
  2281.     is not passed in r3.
  2282.  
  2283.     Assembler programmers may use the macro _REMTAIL located in
  2284.     'powerpc/listsPPC.i'
  2285.  
  2286.     This function is safe to call from exception handlers.
  2287.  
  2288.     SEE ALSO
  2289.     InsertPPC, AddTailPPC, AddHeadPPC, RemovePPC, RemHeadPPC,
  2290.     EnqueuePPC, FindNamePPC, powerpc/listsPPC.i
  2291.  
  2292. powerpc.library/RemSemaphorePPC                powerpc.library/RemSemaphorePPC
  2293.  
  2294.     NAME
  2295.     RemSemaphorePPC - removes a global signal semaphore (V8)
  2296.  
  2297.     CPU
  2298.     PowerPC
  2299.  
  2300.     SYNOPSIS
  2301.     RemSemaphorePPC(_PowerPCBase, SignalSemaphorePPC)
  2302.             r3            r4
  2303.  
  2304.     void RemSemaphorePPC(struct Library *, struct SignalSemaphorePPC *);
  2305.  
  2306.     FUNCTION
  2307.     Removes a global signal semaphore created by AddSemaphorePPC. This
  2308.     is the mirror function of exec/RemSemaphore.
  2309.  
  2310.     INPUTS
  2311.     _PowerPCBase - base of powerpc.library
  2312.     SignalSemaphorePPC - pointer to a signalsemaphorePPC structure
  2313.  
  2314.     SEE ALSO
  2315.     InitSemaphorePPC, FreeSemaphorePPC, ObtainSemaphorePPC,
  2316.     AttemptSemaphorePPC, ReleaseSemaphorePPC, AddSemaphorePPC,
  2317.     FindSemaphorePPC, powerpc/semaphoresPPC.i
  2318.  
  2319. powerpc.library/ReplyMsgPPC                        powerpc.library/ReplyMsgPPC
  2320.  
  2321.     NAME
  2322.     ReplyMsgPPC - put a message to its reply port (V11)
  2323.  
  2324.     CPU
  2325.     PowerPC
  2326.  
  2327.     SYNOPSIS
  2328.     ReplyMsgPPC(_PowerPCBase, message)
  2329.             r3            r4
  2330.  
  2331.     void ReplyMsgPPC(struct Library *, struct Messge *);
  2332.  
  2333.     FUNCTION
  2334.     This function sends a message to its reply port, if one is present.
  2335.     This is the mirror function of exec/ReplyMsg.
  2336.  
  2337.     INPUTS
  2338.     _PowerPCBase - base of powerpc.library
  2339.     message - a pointer to the message to be replied
  2340.  
  2341.     NOTES
  2342.     This function is safe to call from exception handlers.
  2343.  
  2344.     SEE ALSO
  2345.     WaitPortPPC, PutMsgPPC, GetMsgPPC, powerpc/portsPPC.i
  2346.  
  2347. powerpc.library/Run68K                                  powerpc.library/Run68K
  2348.  
  2349.     NAME
  2350.     Run68K - runs a 680x0 function resp. AMIGA-OS library function (V7)
  2351.  
  2352.     CPU
  2353.     PowerPC
  2354.  
  2355.     SYNOPSIS
  2356.     status = Run68K(_PowerPCBase, PPStruct )
  2357.     r3              r3           r4
  2358.  
  2359.     LONG RunPPC (struct Library *, struct PowerPC *);
  2360.  
  2361.     FUNCTION
  2362.     Runs a 680x0 function or an AMIGA-OS library function. All registers
  2363.     can be transferred to 68K as well as parameters on stack. All cache
  2364.     management actions are handled automatically.
  2365.  
  2366.     All registers are transferred back from 68K after the 68K call
  2367.     is completed. They are stored in the PowerPC structure.
  2368.  
  2369.     See RunPPC for the register assignment.
  2370.  
  2371.     INPUTS
  2372.     _PowerPCBase - base of powerpc.library
  2373.     PPStruct - Pointer to an initialized PowerPC Structure
  2374.  
  2375.       PP_CODE       : Pointer to the 680x0 code resp. pointer to the
  2376.               library base (if PP_OFFSET is not zero).
  2377.       PP_OFFSET     : Library offset or 0 if no library function is
  2378.               called.
  2379.       PP_FLAGS      : Flags which can be ore'd together
  2380.       - PP[F/P]_ASYNC   : call 68K function asynchronely (PPC process
  2381.                   returns immediately)
  2382.       PP_STACKPTR   : Pointer to the arguments on the stack to be
  2383.               transferred. The pointer must point to the top
  2384.               of the calling process' stackframe. The stack area
  2385.               to be transferred is located at offset 24 from this
  2386.               position. If no arguments on stack should be
  2387.               transferred, set this to zero.
  2388.       PP_STACKSIZE  : Size of the stack area to be transferred. If no
  2389.               stack parameters should be transferred, set this
  2390.               to zero.
  2391.       PP_REGS       : Array of longwords where the registers to be
  2392.               transferred can be stored (d0-a6)
  2393.       PP_FREGS      : Array of quadwords (8 bytes) where the FP-registers
  2394.               to be transferred can be stored (fp0-fp7)
  2395.  
  2396.     RESULT
  2397.     status - PPERR_SUCCESS if the call was successfully
  2398.          PPERR_ASYNCERR if a synchrone 68K call was made after an
  2399.                 asynchrone 68K call
  2400.  
  2401.     NOTES
  2402.     Calling a 68K function asynchronely is dangerous. Take care of
  2403.     possible cache conflicts. Avoid calling system functions as much
  2404.     as possible.
  2405.  
  2406.     If an asynchrone 68K call is done, the function WaitFor68K MUST be
  2407.     called ONCE after the call was done. No other 68K call is allowed
  2408.     for this PPC process after an asynchrone 68K call and before a call
  2409.     to WaitFor68K.
  2410.  
  2411.     If an asynchronely called 68K function performs a PPC call, the call
  2412.     is only performed when WaitFor68K is called by the PPC process. Note
  2413.     that the 68K mirror process is still connected to the calling PPC
  2414.     process.
  2415.  
  2416.     DON'T pass arguments on stack when calling a 68K function asynchronely.
  2417.     The stack is most likely to be trashed before it is copied to the 68K
  2418.     stack.
  2419.  
  2420.     Assembler programmers should use the macros RUN68K and
  2421.     RUN68K_XL located in the include file 'powerpc/powerpc.i'
  2422.  
  2423.     SEE ALSO
  2424.     WaitFor68K,powerpc/powerpc.i
  2425.  
  2426. powerpc.library/SetCache                              powerpc.library/SetCache
  2427.  
  2428.     NAME
  2429.     SetCache - cache manipulation function (V8)
  2430.  
  2431.     CPU
  2432.     PowerPC
  2433.  
  2434.     SYNOPSIS
  2435.     SetCache(_PowerPCBase, cacheflags, start, length)
  2436.          r3            r4          r5     r6
  2437.  
  2438.     void SetCache(struct Library *, ULONG, void *, ULONG);
  2439.  
  2440.     FUNCTION
  2441.     This function offers many possibilities to affect the caches of
  2442.     the PPC. It performs the action defined by the cache flags. Only
  2443.     one action can be performed at the same time.
  2444.  
  2445.     INPUTS
  2446.     _PowerPCBase - base of powerpc.library
  2447.     cacheflags - action to be performed:
  2448.         CACHE_DCACHEOFF:    Data cache is disabled. The Cache is flushed
  2449.                 automatically.
  2450.         CACHE_DCACHEON:     Data cache is enabled.
  2451.         CACHE_DCACHELOCK:   Data cache is locked (is ignored if either
  2452.                 'start' or 'length' is zero).
  2453.         CACHE_DCACHEUNLOCK: Data cache is unlocked.
  2454.         CACHE_DCACHEFLUSH:  Data cache is flushed.
  2455.         CACHE_ICACHEOFF:    Instruction cache is disabled.
  2456.         CACHE_ICACHEON:     Instruction cache is enabled.
  2457.         CACHE_ICACHELOCK:   Instruction cache is locked.
  2458.         CACHE_ICACHEUNLOCK: Instruction cache is unlocked.
  2459.         CACHE_ICACHEINV:    Instruction cache is invalidated.
  2460.  
  2461.     start - pointer to the start address of the area to be affected.
  2462.         The following cacheflags support an area specification:
  2463.         CACHE_DCACHELOCK, CACHE_DCACHEFLUSH, CACHE_ICACHEINV
  2464.  
  2465.         if 'start' is 0 the whole address space is affected
  2466.  
  2467.     length - length of the area to be affected (see above for the
  2468.          cache flags which support area specification).
  2469.          if 'length' is 0 the whole address space is affected
  2470.  
  2471.     NOTES
  2472.     Invalidating the whole instruction cache is much more efficient
  2473.     than flushing only a part of it.
  2474.  
  2475.     Flushing the whole data cache is less efficient than flushing
  2476.     a specific area, if this area is not too large.
  2477.  
  2478.     The cacheflag DCACHELOCK requires 'start' and 'length' to be not
  2479.     zero. The area specified is then copied into the data cache and
  2480.     the data cache is locked afterwards.
  2481.  
  2482.     The caches should not be switched on/off resp. locked/unlocked
  2483.     without GOOD justification. Global manipulations of the cache
  2484.     should be avoided. Better affect the cache locally by using
  2485.     AllocVecPPC.
  2486.  
  2487.     This function is safe to call from exception handlers
  2488.  
  2489.     SEE ALSO
  2490.     powerpc/powerpc.i
  2491.  
  2492. powerpc.library/SetExcHandler                    powerpc.library/SetExcHandler
  2493.  
  2494.     NAME
  2495.     SetExcHandler - insert a custom exception handler (V9)
  2496.  
  2497.     CPU
  2498.     PowerPC
  2499.  
  2500.     SYNOPSIS
  2501.     XLock = SetExcHandler(_PowerPCBase, ExcTags)
  2502.     r3                    r3            r4
  2503.  
  2504.     void *SetExcHandler(struct Library *, struct TagItem *);
  2505.  
  2506.     FUNCTION
  2507.     This function allows applications to insert custom exception
  2508.     handlers. Those handlers can be global or task dependant,
  2509.     priorities are also supported. Multiple exceptions can be
  2510.     selected for one exception handler.
  2511.  
  2512.     The exception handlers are executed in supervisor mode and
  2513.     have access to all supervisor registers.
  2514.  
  2515.     The handlers are called in one of two possible ways (dependant
  2516.     of the tag EXC_FLAGS):
  2517.  
  2518.     1) EXC_FLAGS has the flag EXCF_SMALLCONTEXT set:
  2519.  
  2520.  
  2521.        Status = CustomHandler(SmallContext)
  2522.        r3                     r3
  2523.  
  2524.        ULONG CustomHandler(struct XCONTEXT*)
  2525.  
  2526.        Inputs:
  2527.         SmallContext - a pointer to a XCONTEXT structure (see
  2528.                    powerpc/powerpc.i)
  2529.  
  2530.        Result:
  2531.         Status - a return value which decides, whether the
  2532.              exception should be leaved immediately or
  2533.              if following exception handlers should be
  2534.              executed, too (see powerpc/powerpc.i)
  2535.  
  2536.  
  2537.       In this first method, the handler gets all registers directly,
  2538.       except for r3, which is passed in the XCONTEXT structure. The
  2539.       exception ID, which gives information about the kind of
  2540.       exception occurred, is passed also in XCONTEXT structure.
  2541.  
  2542.       All registers which are modified by the exception handler are
  2543.       also modified for the interrupted task. If r3 should be modified
  2544.       for the interrupted task, the appropriate field of the XCONTEXT
  2545.       structure has to be modified.
  2546.  
  2547.       Some of the interrupted task's registers are passed in special
  2548.       supervisor registers. If they should be changed, the appropriate
  2549.       supervisor registers have to be changed:
  2550.  
  2551.       SPRG1 -       The interrupted task's Link Register
  2552.       SPRG2 -       The interrupted task's Stackpointer (r1)
  2553.       SPRG3 -       The interrupted task's Smalldata Base (r2)
  2554.  
  2555.       The exception stack, which is passed in r1, is allocated from the
  2556.       user stack of the interrupted task.
  2557.  
  2558.  
  2559.     2) EXC_FLAGS has the flag EXCF_LARGECONTEXT set:
  2560.  
  2561.  
  2562.        Status = CustomHandler(LargeContext)
  2563.        r3                     r3
  2564.  
  2565.        ULONG CustomHandler(struct EXCCONTEXT*)
  2566.  
  2567.        Inputs:
  2568.         LargeContext - a pointer to a EXCCONTEXT structure (see
  2569.                    powerpc/powerpc.i)
  2570.  
  2571.        Result:
  2572.         Status - a return value which decides, whether the
  2573.              exception should be leaved immediately or
  2574.              if following exception handlers should be
  2575.              executed, too (see powerpc/powerpc.i)
  2576.  
  2577.       In this second method, the handler gets all registers in the
  2578.       EXCCONTEXT structure. If the handler wishes to change some
  2579.       of the register contents it must change the appropriate fields
  2580.       in the EXCCONTEXT structure which are copied back to the
  2581.       registers after the custom handler has completed. If no
  2582.       field is provided for a certain register, it has to be modified
  2583.       directly.
  2584.  
  2585.       The exception stack, which is passed in r1, is allocated from the
  2586.       user stack of the interrupted task.
  2587.  
  2588.     INPUTS
  2589.     _PowerPCBase - base of powerpc.library
  2590.     ExcTags - pointer to a tagitem array. The following tags are
  2591.           supported:
  2592.  
  2593.         EXCATTR_CODE:       pointer to the exception handler code
  2594.                 (required)
  2595.         EXCATTR_DATA:       a user data which is passed in r2 to the
  2596.                 custom exception handler. This is usually
  2597.                 a base register which provides access to
  2598.                 all global data required.
  2599.         EXCATTR_TASK:       specifies the task which is allowed to take
  2600.                 the exception handler. If this tag is 0 or
  2601.                 omitted, the current task is taken instead.
  2602.                 This tag has no effect if the exception
  2603.                 handler is specified as global (see below
  2604.                 at EXCATTR_FLAGS)
  2605.         EXCATTR_EXCID:      Defines which exceptions should call this
  2606.                 exception handler. See powerpc/powerpc.i
  2607.                 for a description of all supported exceptions.
  2608.                 Multiple exceptions can be selected.
  2609.         EXCATTR_FLAGS:
  2610.         EXCF_GLOBAL:       Marks the exception handler as global. It
  2611.                    is then called for every exception occurred.
  2612.         EXCF_LOCAL:        Marks the exception handler as local. It is
  2613.                    then only called, if the interrupted task
  2614.                    matches the task specified in EXCATTR_TASK.
  2615.         EXCF_SMALLCONTEXT: The exception handler is called with a
  2616.                    XCONTEXT structure as parameter (see above
  2617.                    for a description of this mode).
  2618.         EXCF_LARGECONTEXT: The exception handler is called with a
  2619.                    EXCCONTEXT structure as parameter (see above
  2620.                    for a description of this mode).
  2621.  
  2622.                 One flag of EXCF_GLOBAL and EXCF_LOCAL and one
  2623.                 flag of EXCF_SMALLCONTEXT and EXCF_LARGECONTEXT
  2624.                 must be specified, otherwise this function
  2625.                 fails.
  2626.  
  2627.         EXCATTR_NAME:       An identification name for this handler
  2628.         EXCATTR_PRI:        The priority of this exception handler
  2629.  
  2630.     RESULT
  2631.     XLock - A lock to be passed to RemExcHandler or 0 if something
  2632.         failed.
  2633.  
  2634.     NOTES
  2635.     Exception handlers should generally take care that they don't
  2636.     destroy any registers of the interrupted task except if it is
  2637.     desired. Special care must be taken if the exception handler is
  2638.     called with the small context structure (take care of r0!). All
  2639.     registers, inclusive CR, CTR, LR and others must be restored if
  2640.     they should not be changed.
  2641.  
  2642.     IMPORTANT: The exception handler is called with MMU switched off!
  2643.     The whole address space is accessed in cachable copyback mode, so
  2644.     no access to critical locations such as custom chip space must
  2645.     be performed. If such locations should be accessed, a temporary
  2646.     MMU setup must be done using the library functions 'SetExcMMU'
  2647.     and 'ClearExcMMU' (V10)
  2648.  
  2649.     Note that changes to the MSR of the interrupted task must be done
  2650.     by writing to SRR1 (i.e. setting the trace bit).
  2651.  
  2652.     Note that exception handlers should generally not call system
  2653.     functions with some exceptions (for example 'SignalPPC' is often
  2654.     useful to call from exception handlers). System functions must not
  2655.     be called unless it's allowed explicitely by the documentation of
  2656.     each function.
  2657.  
  2658.     Note that the content of the program counter (SRR0) differs depending
  2659.     on the exception type. Sometimes it contains the address of the
  2660.     excepting instruction and sometimes the address of the next
  2661.     instruction to complete. Exception handlers must take care about
  2662.     this and should set the program counter appropriately.
  2663.     Here follows a table of all supported exceptions and their behaviour:
  2664.  
  2665.     Machine check (EXCF_MCHECK):        PC -> maybe next instruction
  2666.     Data access (EXCF_DACCESS):         PC -> excepting instruction
  2667.     Instruction access (EXCF_IACCESS):  PC -> next instruction
  2668.     Alignment (EXCF_ALIGN):             PC -> excepting instruction
  2669.     Program (EXCF_PROGRAM):             PC -> excepting instruction
  2670.     FP unavailable (EXCF_FPUN):         PC -> excepting instruction
  2671.     Trace (EXCF_TRACE):                 PC -> next instruction
  2672.     Performance Monitor (EXCF_PERFMON): unknown
  2673.     Instruction breakpoint (EXCF_IABR): PC -> excepting instruction
  2674.  
  2675.     Exception handlers should not waste stack space. The system
  2676.     allocates an extra space for this purpose but it may not be
  2677.     sufficient if very stack-intensive routines are called as
  2678.     exception handlers.
  2679.  
  2680.     If every exception handler returns the state EXCRETURN_NORMAL
  2681.     then the standard WarpOS exception handler is executed (except
  2682.     for Trace- and PerformanceMonitor-Exceptions).
  2683.  
  2684.     If exception handlers are written to emulate commands causing
  2685.     an exception they should return EXCRETURN_ABORT as return value
  2686.     to suppress following exception handlers which might output
  2687.     some alert messages. The priority should be probably high enough
  2688.     to ensure that no unwanted reactions occur.
  2689.  
  2690.     The WarpOS debugging system is disabled during exception
  2691.     processing.
  2692.  
  2693.     It's completely ILLEGAL to exit an exception handler by an RFI
  2694.     instruction!! It's also illegal to trash SPRG0!
  2695.  
  2696.     SEE ALSO
  2697.     RemExcHandler, powerpc/powerpc.i
  2698.  
  2699. powerpc.library/SetExcMMU                            powerpc.library/SetExcMMU
  2700.  
  2701.     NAME
  2702.     SetExcMMU - installs a BAT based MMU setup for exception handlers (V10)
  2703.  
  2704.     CPU
  2705.     PowerPC
  2706.  
  2707.     SYNOPSIS
  2708.     SetExcMMU(_PowerPCBase)
  2709.           r3
  2710.  
  2711.     void SetExcMMU(struct Library *);
  2712.  
  2713.     FUNCTION
  2714.     This function is for exception handlers only. It installs a new
  2715.     temporary MMU setup which allows exception handlers to access critical
  2716.     address space, such as custom chip space. Exception handlers are
  2717.     normally run with MMU switched off to avoid problems on systems
  2718.     without hardware tablesearch.
  2719.  
  2720.     The new MMU setup is based on the BAT registers.
  2721.  
  2722.     The function 'ClearExcMMU' restores the old MMU state and should
  2723.     be called at the end of the exception handler.
  2724.  
  2725.  
  2726.     INPUTS
  2727.     _PowerPCBase - base of powerpc.library
  2728.  
  2729.     NOTES
  2730.     This function must not be called from anywhere else than from
  2731.     an exception handler.
  2732.  
  2733.     SEE ALSO
  2734.     ClearExcMMU
  2735.  
  2736. powerpc.library/SetHardware                        powerpc.library/SetHardware
  2737.  
  2738.     NAME
  2739.     SetHardware - hardware manipulation function (V9)
  2740.  
  2741.     CPU
  2742.     PowerPC
  2743.  
  2744.     SYNOPSIS
  2745.     Status = SetHardware(_PowerPCBase, hardwareflags, parameter)
  2746.                  r3            r4             r5
  2747.  
  2748.     ULONG SetHardware(struct Library *, ULONG, void *);
  2749.  
  2750.     FUNCTION
  2751.     This function offers some functions to access the PPC hardware.
  2752.  
  2753.     INPUTS
  2754.     _PowerPCBase - base of powerpc.library
  2755.     hardwareflags - action to be performed:
  2756.         HW_TRACEON:         Enables trace mode for the current task
  2757.         HW_TRACEOFF:        Disables trace mode for the current task
  2758.         HW_BRANCHTRACEON:   Enables branch trace mode for the current task
  2759.         HW_BRANCHTRACEOFF:  Disables branch trace mode for the current task
  2760.         HW_FPEXCON:         Enables the floating point exceptions for the
  2761.                 current task
  2762.         HW_FPEXCOFF:        Disables the floating point exceptions for the
  2763.                 current task
  2764.         HW_SETIBREAK:       Sets the global instruction breakpoint
  2765.         HW_CLEARIBREAK:     Clears the global instruction breakpoint
  2766.         HW_SETDBREAK:       Sets the global data breakpoint
  2767.         HW_CLEARDBREAK:     Clears the global data breakpoint
  2768.  
  2769.     parameter - additional parameter only used if a breakpoint should be
  2770.             set. Then it contains the breakpoint address.
  2771.  
  2772.     RESULT
  2773.     Status - HW_AVAILABLE: The requested feature is available on this CPU
  2774.          HW_NOTAVAILABLE: The requested feature is not available on
  2775.                   this CPU
  2776.  
  2777.     NOTES
  2778.     Floating point exceptions are only enabled globally with HW_FPEXCON.
  2779.     It's necessary to call 'ModifyFPExc' to enable the desired floating
  2780.     point exceptions.
  2781.  
  2782.     Floating point exceptions should not be enabled by standard
  2783.     applications. They are intended to use for debugging purposes.
  2784.  
  2785.     The data breakpoint feature is not available on PPC603[E].
  2786.  
  2787.     SEE ALSO
  2788.     ModifyFPExc, powerpc/powerpc.i
  2789.  
  2790. powerpc.library/SetReplyPortPPC                powerpc.library/SetReplyPortPPC
  2791.  
  2792.     NAME
  2793.     SetReplyPortPPC - exchanges the reply port of a message (V13)
  2794.  
  2795.     CPU
  2796.     PowerPC
  2797.  
  2798.     SYNOPSIS
  2799.     OldPort = SetReplyPortPPC(_PowerPCBase, Message, MsgPortPPC)
  2800.     r3                        r3            r4       r5
  2801.  
  2802.     struct MsgPortPPC* SetReplyPortPPC(struct Library *,
  2803.                struct Message *, struct MsgPortPPC *);
  2804.  
  2805.     FUNCTION
  2806.     This function exchanges the message port of a message. It
  2807.     can be used for internal PPC messages and for InterCPU
  2808.     messages.
  2809.  
  2810.     INPUTS
  2811.     _PowerPCBase - base of powerpc.library
  2812.     Message - a pointer to the message affected
  2813.     MsgPortPPC - a pointer to a PPC message port
  2814.  
  2815.     RESULT
  2816.     The old reply port, which was installed in the message.
  2817.     Can be NULL, of course.
  2818.  
  2819.     NOTES
  2820.     It's possible to specify NULL as MsgPort to remove the
  2821.     reply port.
  2822.  
  2823.     Don't poke into the message structure at MN_REPLYPORT,
  2824.     please use this function here.
  2825.  
  2826.     SEE ALSO
  2827.     WaitPortPPC, GetMsgPPC, ReplyMsgPPC, PutMsgPPC, powerpc/portsPPC.i
  2828.  
  2829. powerpc.library/SetSignalPPC                      powerpc.library/SetSignalPPC
  2830.  
  2831.     NAME
  2832.     SetSignalPPC - define the state of this task's signals (V8)
  2833.  
  2834.     CPU
  2835.     PowerPC
  2836.  
  2837.     SYNOPSIS
  2838.     oldSignals = SetSignalPPC(_PowerPCBase, newSignals, signalMask)
  2839.     r3                        r3            r4          r5
  2840.  
  2841.     ULONG SetSignalPPC(struct Library *, ULONG, ULONG);
  2842.  
  2843.     FUNCTION
  2844.     This function can query or modify the state of the current
  2845.     signals. This function is the mirror function of exec/SetSignal.
  2846.  
  2847.     INPUTS
  2848.     _PowerPCBase - base of powerpc.library
  2849.     newSignals - the new values for the signals
  2850.     signalMask - the set of signals to be affected.
  2851.  
  2852.     RESULT
  2853.     oldSignals - the prior values for all signals
  2854.  
  2855.     NOTES
  2856.     It's possible to check for the system signals (i.e. CTRL_C).
  2857.  
  2858.     Before V11, this only worked if the task was stated using
  2859.     RunPPC, this is not the case anymore.
  2860.  
  2861.     SEE ALSO
  2862.     AllocSignalPPC, FreeSignalPPC, SignalPPC, WaitPPC
  2863.  
  2864. powerpc.library/SetTaskPriPPC                    powerpc.library/SetTaskPriPPC
  2865.  
  2866.     NAME
  2867.     SetTaskPriPPC - get and set the priority of a task (V8)
  2868.  
  2869.     CPU
  2870.     PowerPC
  2871.  
  2872.     SYNOPSIS
  2873.     oldpriority = SetTaskPriPPC(_PowerPCBase, taskPPC, priority)
  2874.     r3                          r3            r4       r5
  2875.  
  2876.     LONG SetTaskPriPPC(struct Library *, struct TaskPPC *, LONG);
  2877.  
  2878.     FUNCTION
  2879.     This function changes the priority of a task regardless of its
  2880.     state. The old priority of the task is returned. A reschedule
  2881.     may be performed. This is the mirror function of exec/SetTaskPri.
  2882.  
  2883.     INPUTS
  2884.     _PowerPCBase - base of powerpc.library
  2885.     taskPPC - task to be affected
  2886.     priority - the new priority for the task
  2887.  
  2888.     RESULT
  2889.     old priority - the tasks previous priority
  2890.  
  2891. powerpc.library/Signal68K                            powerpc.library/Signal68K
  2892.  
  2893.     NAME
  2894.     SignalPPC - signal a 68K task (V8)
  2895.  
  2896.     CPU
  2897.     PowerPC
  2898.  
  2899.     SYNOPSIS
  2900.     Signal68K(_PowerPCBase, task, signals)
  2901.           r3            r4       r5
  2902.  
  2903.     void Signal68K(struct Library *, struct Task*, ULONG);
  2904.  
  2905.     FUNCTION
  2906.     This function signals a 68K task with the given signals. If
  2907.     the signalled task is sleeping, it's woken up and a reschedule
  2908.     may occur.
  2909.  
  2910.     INPUTS
  2911.     _PowerPCBase - base of powerpc.library
  2912.     task - the 68K task to be signalled
  2913.     signals - the signals to be sent
  2914.  
  2915. powerpc.library/SignalPPC                            powerpc.library/SignalPPC
  2916.  
  2917.     NAME
  2918.     SignalPPC - signal a task (V8)
  2919.  
  2920.     CPU
  2921.     PowerPC
  2922.  
  2923.     SYNOPSIS
  2924.     SignalPPC(_PowerPCBase, taskPPC, signals)
  2925.           r3            r4       r5
  2926.  
  2927.     void SignalPPC(struct Library *, struct TaskPPC*, ULONG);
  2928.  
  2929.     FUNCTION
  2930.     This function signals a task with the given signals. If the
  2931.     signalled task is sleeping, it's woken up and a reschedule
  2932.     may occur. This is the mirror function of exec/Signal.
  2933.  
  2934.     INPUTS
  2935.     _PowerPCBase - base of powerpc.library
  2936.     taskPPC - the task to be signalled
  2937.     signals - the signals to be sent
  2938.  
  2939.     NOTES
  2940.     This function is safe to call from exception handlers.
  2941.  
  2942.     Since V11 it's possible to signal a 68K task directly
  2943.     with 'SignalPPC' and the 68K task structure in r4.
  2944.  
  2945.     Before V11, 'SignalPPC' only worked, if the PPC task
  2946.     had a mirror 68K task. Since V11, every PPC task has
  2947.     a mirror task, so 'SignalPPC' can always be used.
  2948.  
  2949.     Furthermore, all signals, which are sent to a task currently
  2950.     waiting for its mirror task to complete, are transferred
  2951.     automatically to the mirror task. In fact, the whole signal
  2952.     system is shared and can be viewed as one single 'virtual
  2953.     signaling system'. It really doesn't matter, on which CPU
  2954.     a program is running, the signals are always transferred to
  2955.     the currently active part.
  2956.  
  2957.  
  2958.  
  2959.     SEE ALSO
  2960.     AllocSignalPPC, FreeSignalPPC, SetSignalPPC, WaitPPC
  2961.  
  2962. powerpc.library/SnoopTask                            powerpc.library/SnoopTask
  2963.  
  2964.     NAME
  2965.     SnoopTask - monitors beginning or end of a PPC task (V13)
  2966.  
  2967.     CPU
  2968.     PowerPC
  2969.  
  2970.     SYNOPSIS
  2971.     SnoopID = SnoopTask (_PowerPCBase, SnoopTags)
  2972.     r3                   r3            r4
  2973.  
  2974.     ULONG SnoopTask (struct Library *, struct TagItem *);
  2975.  
  2976.     FUNCTION
  2977.     This function allows to intall a callback job, which is executed
  2978.     when a new PPC task is started or when a PPC task is removed.
  2979.     This is useful for debuggers which want to be kept informed
  2980.     about new tasks installed into the system and about tasks removed
  2981.     from the system.
  2982.  
  2983.     The callback function has two different formats (prototypes),
  2984.     dependant on the type of callback:
  2985.  
  2986.     1. callback function for monitoring the beginning of a PPC task
  2987.        (SNOOP_TYPE = TASK_START)
  2988.  
  2989.        SYNOPSIS:
  2990.  
  2991.        CallbackFunction (PPCTask, EntryCode, CreatorTask, CreatorCPU)
  2992.                  r3       r4         r5           r6
  2993.  
  2994.        void CallbackFunction (struct TaskPPC *, APTR, struct Task *, ULONG);
  2995.  
  2996.        INPUTS:
  2997.        PPCTask - pointer to the new PPC task which is created
  2998.        EntryCode - pointer to the start code, which will be executed
  2999.                by the new task
  3000.        CreatorTask - pointer to the task structure of the task, which
  3001.              created the new PPC task. If the new task is created
  3002.              due to a call of RunPPC from 68K side, then the
  3003.              CreatorTask points to the 68K-Task-Structure. If
  3004.              the PPC task was created by directly calling
  3005.              'CreateTaskPPC', CreatorTask points to this PPC task.
  3006.        CreatorCPU - One of two possible values:
  3007.             CREATOR_PPC : The new PPC task was created using
  3008.                       'CreateTaskPPC' by a PPC task.
  3009.             CREATOR_68K : The new PPC task was created using
  3010.                       'RunPPC' by a 68K task.
  3011.  
  3012.  
  3013.     2. callback function for monitoring the end of a PPC task
  3014.        (SNOOP_TYPE = TASK_EXIT)
  3015.  
  3016.        SYNOPSIS:
  3017.  
  3018.        CallbackFunction (PPCTask)
  3019.                  r3
  3020.  
  3021.        void CallbackFunction (struct TaskPPC *);
  3022.  
  3023.        INPUTS:
  3024.        PPCTask - pointer to the PPC task which is removed. NEVER use
  3025.              FindTaskPPC(NULL), because it's possible that a PPC
  3026.              task is removed by another PPC task!
  3027.  
  3028.     INPUTS
  3029.     _PowerPCBase - base of powerpc.library
  3030.     TagItems - pointer to a tagitem array. The following tags are
  3031.            supported:
  3032.  
  3033.         SNOOP_CODE:         pointer to the callback function which should
  3034.                 be called, if a new PPC task is created or
  3035.                 if a PPC task is removed.
  3036.         SNOOP_DATA:         custom data which passed in register r2.
  3037.                 this will usually be the smalldata base of
  3038.                 the task which wants to snoop other tasks
  3039.                 to gain access to more data space.
  3040.         SNOOP_TYPE:         two possible values:
  3041.                 SNOOP_START : The callback function is called
  3042.                           when a new PPC task is created
  3043.                 SNOOP_EXIT  : The callback function is called
  3044.                           when a PPC task is removed
  3045.     RESULT
  3046.     SnoopID - An ID, which must be passed to EndSnoopTask, as soon as the
  3047.           snooping action should be terminated. NULL, if an error
  3048.           occurs.
  3049.  
  3050.     SEE ALSO
  3051.     EndSnoopTask
  3052.  
  3053. powerpc.library/SPrintF                                powerpc.library/SPrintF
  3054.  
  3055.     NAME
  3056.     SPrintF - prints a formatted string to the serial port (V7)
  3057.  
  3058.     CPU
  3059.     PowerPC
  3060.  
  3061.     SYNOPSIS
  3062.     SPrintF (_PowerPCBase, Formatstring, values )
  3063.          r3             r4             r5
  3064.  
  3065.     void SPrintF (struct Library *, STRPTR, APTR);
  3066.  
  3067.     FUNCTION
  3068.     Prints a formatted string to the serial port using the AMIGA-OS
  3069.     functions 'exec/RawPutChar' and 'exec/RawDoFmt'. Can be used to add
  3070.     debugging features and to improve the maintenance of software.
  3071.  
  3072.     INPUTS
  3073.     _PowerPCBase - base of powerpc.library
  3074.     Formatstring - A C style string with % commands to indicate where
  3075.                parameters have to be inserted (see 'exec/RawDoFmt'
  3076.                for a detailed description of these commands).
  3077.     values - A pointer to an array of parameters to be inserted into
  3078.          specified places in the string.
  3079.  
  3080.     SEE ALSO
  3081.     exec/RawDoFmt
  3082.  
  3083. powerpc.library/SubTimePPC                          powerpc.library/SubTimePPC
  3084.  
  3085.     NAME
  3086.     SubTimePPC - subtracts one time request from another (V7)
  3087.  
  3088.     CPU
  3089.     PowerPC
  3090.  
  3091.     SYNOPSIS
  3092.     SubTimePPC(_PowerPCBase, Dest, Source)
  3093.            r3            r4    r5
  3094.  
  3095.     void SubTimePPC(struct Library *, struct timeval *, struct timeval *);
  3096.  
  3097.     FUNCTION
  3098.     This routine subtracts one timeval structure from another. The results
  3099.     are stored in the destination (Dest - Source -> Dest)
  3100.  
  3101.     This is the mirror function of timer/SubTime.
  3102.  
  3103.     INPUTS
  3104.     _PowerPCBase - base of powerpc.library
  3105.     Dest - pointer to a timeval structure
  3106.     Source - pointer to a timeval structure
  3107.  
  3108.     NOTES
  3109.     This function is safe to call from exception handlers
  3110.  
  3111.     SEE ALSO
  3112.     GetSysTimePPC, AddTimePPC, CmpTimePPC
  3113.  
  3114. powerpc.library/Super                                    powerpc.library/Super
  3115.  
  3116.     NAME
  3117.     Super - switch to supervisor mode (V9)
  3118.  
  3119.     CPU
  3120.     PowerPC
  3121.  
  3122.     SYNOPSIS
  3123.     SuperKey = Super(_PowerPCBase)
  3124.     r3               r3
  3125.  
  3126.     ULONG Super(struct Library *);
  3127.  
  3128.     FUNCTION
  3129.     This function changes the current task to supervisor mode.
  3130.  
  3131.     INPUTS
  3132.     _PowerPCBase - base of powerpc.library
  3133.  
  3134.     RESULT
  3135.     SuperKey - A key value which must be passed to 'User' to switch back
  3136.            to user mode
  3137.  
  3138.     NOTES
  3139.     Applications should generally not enter supervisor mode. Check first
  3140.     if there exists a library function which gives you access to the
  3141.     supervisor resources required.
  3142.  
  3143.     SEE ALSO
  3144.     User
  3145.  
  3146. powerpc.library/UnLockTaskList                  powerpc.library/UnLockTaskList
  3147.  
  3148.     NAME
  3149.     UnLockTaskList - unlocks a list locked by LockTaskList (V10)
  3150.  
  3151.     CPU
  3152.     PowerPC
  3153.  
  3154.     SYNOPSIS
  3155.     UnLockTaskList(_PowerPCBase)
  3156.                r3
  3157.  
  3158.     void UnLockTaskList(struct Library *);
  3159.  
  3160.     FUNCTION
  3161.     Unlocks the task list which was locked by LockTaskList
  3162.  
  3163.     INPUTS
  3164.     _PowerPCBase - base of powerpc.library
  3165.  
  3166.     SEE ALSO
  3167.     LockTaskList, powerpc/tasksppc.i
  3168.  
  3169. powerpc.library/User                                      powerpc.library/User
  3170.  
  3171.     NAME
  3172.     User - switch to user mode (V9)
  3173.  
  3174.     CPU
  3175.     PowerPC
  3176.  
  3177.     SYNOPSIS
  3178.     User(_PowerPCBase, SuperKey)
  3179.          r3            r4
  3180.  
  3181.     void User(struct Library *, ULONG);
  3182.  
  3183.     FUNCTION
  3184.     This function changes the current task to user mode.
  3185.  
  3186.     INPUTS
  3187.     _PowerPCBase - base of powerpc.library
  3188.     SuperKey - The return value of the matching call of 'Super'
  3189.  
  3190.     SEE ALSO
  3191.     Super
  3192.  
  3193. powerpc.library/WaitFor68K                          powerpc.library/WaitFor68K
  3194.  
  3195.     NAME
  3196.     WaitFor68K - waits for the completion of an asynchrone 68K call (V7)
  3197.  
  3198.     CPU
  3199.     PowerPC
  3200.  
  3201.     SYNOPSIS
  3202.     status = WaitFor68K(_PowerPCBase, PPStruct )
  3203.     r3                  r3             r4
  3204.  
  3205.     LONG WaitFor68K (struct Library *, struct PowerPC *);
  3206.  
  3207.     FUNCTION
  3208.     After an asynchrone 68K call was done (see Run68K) this function must
  3209.     be called to wait for the completion of the 68K function. All
  3210.     registers transferred to the PowerPC with Run68K are returned into the
  3211.     PowerPC Structure.
  3212.  
  3213.     INPUTS
  3214.     _PowerPCBase - base of powerpc.library
  3215.     PPStruct - Pointer to a PowerPC Structure (see Run68K for a description
  3216.            of the elements). The structure has not to be initialized.
  3217.            The structure must be transferred to hold the returned
  3218.            registers by the 68K function.
  3219.  
  3220.     RESULT
  3221.     status - PPERR_SUCCESS if the call was successfully
  3222.          PPERR_WAITERR if WaitFor68K is called after a synchrone 68K
  3223.                    call.
  3224.  
  3225.     NOTES
  3226.     Assembler programmers should use the macros WAITFOR68K and
  3227.     WAITFOR68K_XL located in the include file 'powerpc/powerpc.i'
  3228.  
  3229.     SEE ALSO
  3230.     Run68K,powerpc/powerpc.i
  3231.  
  3232. powerpc.library/WaitPortPPC                        powerpc.library/WaitPortPPC
  3233.  
  3234.     NAME
  3235.     WaitPortPPC - wait for a given port to be non-empty (V11)
  3236.  
  3237.     CPU
  3238.     PowerPC
  3239.  
  3240.     SYNOPSIS
  3241.     message = WaitPortPPC(_PowerPCBase, MsgPortPPC)
  3242.     r3                    r3            r4
  3243.  
  3244.     struct Message *WaitPortPPC(struct Library *, struct MsgPortPPC *);
  3245.  
  3246.     FUNCTION
  3247.     This function waits until the given port becomes non-empty. The
  3248.     first message in the port is returned without removing it from
  3249.     the port. This is the mirror function of exec/WaitPort.
  3250.  
  3251.     INPUTS
  3252.     _PowerPCBase - base of powerpc.library
  3253.     port - a pointer to a message port
  3254.  
  3255.     RESULTS
  3256.     message - a pointer to the first available message
  3257.  
  3258.     SEE ALSO
  3259.     PutMsgPPC, GetMsgPPC, ReplyMsgPPC, powerpc/portsPPC.i
  3260.  
  3261. powerpc.library/WaitPPC                                powerpc.library/WaitPPC
  3262.  
  3263.     NAME
  3264.     WaitPPC - wait for one or more signals (V8)
  3265.  
  3266.     CPU
  3267.     PowerPC
  3268.  
  3269.     SYNOPSIS
  3270.     signals = WaitPPC(_PowerPCBase, signalSet)
  3271.     r3                r3            r4
  3272.  
  3273.     ULONG WaitPPC(struct Library *, ULONG);
  3274.  
  3275.     FUNCTION
  3276.     This function attempts to wait for the given signals. If at
  3277.     least one of these signal is already set, the task returns
  3278.     immediately, otherwise it changes to waiting state. This is
  3279.     the mirror function of exec/Wait.
  3280.  
  3281.     INPUTS
  3282.     _PowerPCBase - base of powerpc.library
  3283.     signalSet - the set of signals for which to wait
  3284.  
  3285.     RESULTS
  3286.     signals - the signals which were received
  3287.  
  3288.     NOTES
  3289.     Since V11 it's possible to wait for signals which might
  3290.     be sent by 68K tasks (and maybe only to the mirror 68K
  3291.     task of this PPC task here). Calling exec/Signal with a
  3292.     PPC task structure as first argument will work, too.
  3293.     See the desription of 'SignalPPC' for more information
  3294.     about the shared signaling system.
  3295.  
  3296.     SEE ALSO
  3297.     AllocSignalPPC, FreeSignalPPC, SetSignalPPC, SignalPPC
  3298.  
  3299. powerpc.library/WaitTime                              powerpc.library/WaitTime
  3300.  
  3301.     NAME
  3302.     WaitTime - wait for a given time or for given signals (V10)
  3303.  
  3304.     CPU
  3305.     PowerPC
  3306.  
  3307.     SYNOPSIS
  3308.     signals = WaitTime(_PowerPCBase, signalSet, time)
  3309.     r3                 r3            r4         r5
  3310.  
  3311.     ULONG WaitTime(struct Library *, ULONG, ULONG);
  3312.  
  3313.     FUNCTION
  3314.     This function attempts to wait for a specific time of for
  3315.     given signals. This function acts just like 'WaitPPC' with
  3316.     the difference that the task returns when the time specified
  3317.     is over.
  3318.  
  3319.     INPUTS
  3320.     _PowerPCBase - base of powerpc.library
  3321.     signalSet - the set of signals for which to wait (can be 0
  3322.             if the task should only wait for a given time)
  3323.     time - the time in microseconds to wait
  3324.  
  3325.     RESULTS
  3326.     signals - the signals which were received (if this value is 0,
  3327.           then the time is up).
  3328.  
  3329.     NOTES
  3330.     The time which explicitly passes between calling 'WaitTime' and
  3331.     returning from it can vary dependant of current system state. If
  3332.     many tasks are active, the time can be delayed. Furthermore the
  3333.     overhead of this function must be taken in account.
  3334.  
  3335.     SEE ALSO
  3336.     WaitPPC
  3337.  
  3338.  
  3339.